/*****************************************************************************\

  Copyright (C) 2009, Aru <oneforaru at gmail dot com>

  The contents of this file is a result of contributions from various people.

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Please see ScriptHook-License.txt for information on how this source/header
  file is licensed as part of the ScriptHook SDK.

\*****************************************************************************/


// GhostGum - 2009.12.09: Converted for GTAScript.Net.



#pragma once
#include <windows.h>
//#include <atlstr.h>
#include <msclr/marshal.h>
#include <stdio.h>
#using <mscorlib.dll>

#include "../ScriptHook/NativeInvoke.h"
#include "../ScriptHook/ScriptingTypes.h"
#include "../ScriptHook/ScriptingEnums.h"
#include "../ScriptHook/ScriptingHelpers.h"
#include "../ScriptHook/ScriptingNatives.h"
#include "../ScriptHook/Scripting.h"
#include "Scripting.h"
#include "World/GameObject.h"
#include "World/Ped.h"
#include "World/Vehicle.h"
#include "World/Player.h"
#include "World/World.h"
#include "Log.h"



using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr::interop;
using namespace Scripting;
namespace GTA
{

	public ref class ScriptApi
	{
	private:
	public:



		// ------------------------
		static void EndCamCommands(u32* unk1) { Scripting::EndCamCommands(unk1);}
		static void BeginCamCommands(u32* unk1) { Scripting::BeginCamCommands(unk1);}
		static void ActivateScriptedCams(u32 unk1_1, u32 unk2_1) { Scripting::ActivateScriptedCams(unk1_1,unk2_1); }

		static u32 CreateCheckpoint(u32 unk_type_2, f32 x, f32 y, f32 z , f32 dirx, f32 diry, f32 dirz, f32 unk_size) { return Scripting::CreateCheckpoint(unk_type_2,x,y,z,dirx,diry,dirz,unk_size); }
		static void DeleteCheckpoint(u32 checkpoint) { return Scripting::DeleteCheckpoint(checkpoint); }

		static void DrawSprite(GTA::Texture^ texture, f32 x, f32 y,f32 xsize, f32 ysize, f32 unk0_0,u32 r, u32 g, u32 b, u32 a) { Scripting::DrawSprite(texture->Base, x, y, xsize, ysize, unk0_0, r, g, b, a); }
		static void DrawTopLevelSprite(GTA::Texture^ texture, f32 x, f32 y,f32 xsize, f32 ysize, f32 unk0_0,u32 r, u32 g, u32 b, u32 a) { Scripting::DrawTopLevelSprite(texture->Base, x, y, xsize, ysize, unk0_0, r, g, b, a); }
		
		static void GetMousePosition(f32* x, f32* y) { Scripting::GetMousePosition(x,y);}

		static void GetScreenResolution(u32* x, u32* y) { Scripting::GetScreenResolution(x,y);}

		static void SetCarCollision(GTA::Vehicle^ veh, bool collisions) { Scripting::SetCarCollision(veh->Base,collisions);}




		//TRIGGER_PTFX_ON_PED_BONE("CS_EXECUTION_BLOOD", var4, 0,1f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1204, (float)1);
		static void TriggerPtfxOnPedBone(String^ ptfxname, GTA::Ped^ ped, u32 unk0_0, f32 unk1_0, f32 unk2_0, f32 unk3_0, f32 unk4_0, f32 unk5_0, GTA::ePedBone bone, f32 unk6_1) 
		{ 
			marshal_context^ conptfxname = gcnew marshal_context();;
			const char* cptfxname = conptfxname->marshal_as<const char*>(ptfxname);
			Scripting::TriggerPtfxOnPedBone(cptfxname,ped->Base,unk0_0,unk1_0,unk2_0,unk3_0,unk4_0,unk5_0,(Scripting::ePedBone)bone,unk6_1);
			delete conptfxname;
			//return 
		}



		static void SetCharNeverTargetted(GTA::Ped^ ped, bool isnevertargetted) { Scripting::SetCharNeverTargetted(ped->Base, isnevertargetted);}
		static void SetCharOnlyDamagedByPlayer(GTA::Ped^ ped, bool isonlydamagedbyplayer) { Scripting::SetCharOnlyDamagedByPlayer(ped->Base, isonlydamagedbyplayer);}

		static void GetVehicleQuaternion(GTA::Vehicle^ veh, f32* w, f32* x, f32* y, f32* z) { Scripting::GetVehicleQuaternion(veh->Base,w,x,y,z);}
		static void SetVehicleQuaternion(GTA::Vehicle^ veh, f32 w, f32 x, f32 y, f32 z) { Scripting::SetVehicleQuaternion(veh->Base,w,x,y,z); }

		static void GetObjectQuaternion(GTA::GameObject^ obj, f32* w, f32* x, f32* y, f32* z) { Scripting::GetObjectQuaternion(obj->Base,w,x,y,z);}
		static void SetObjectQuaternion(GTA::GameObject^ obj, f32 w, f32 x, f32 y, f32 z) { Scripting::SetObjectQuaternion(obj->Base,w,x,y,z); }


		static void AllowReactionAnims(GTA::Ped^ ped, bool isallowed) { Scripting::AllowReactionAnims(ped->Base,isallowed); }

		// -----------------------





		// player
		static void NetworkGetPlayerIDOfNextTextChat (u32* playerID) { return Scripting::NetworkGetPlayerIDOfNextTextChat(playerID); }
		static void ForceNetPlayerInvisible_UNK1 (GTA::Ped^ unk_ped, b8 value) { return Scripting::ForceNetPlayerInvisible_UNK1(unk_ped->Base, value); }

		//ConvertMe//	static constchr* NetworkGetMetPlayerName(u32 unk_plid) { return NativeInvoke::Invoke<char*>("NETWORK_GET_MET_PLAYER_NAME", unk_plid); }
		static Scripting::ScriptAny IsNetworkPlayerActive (u32 unk_plid) { return Scripting::IsNetworkPlayerActive(unk_plid); }
		static u32 FindNetworkKillerOfPlayer (u32 unk_plid) { return Scripting::FindNetworkKillerOfPlayer(unk_plid); }

		// object
		static void SetObjectRotation (GTA::GameObject^ obj, f32 x, f32 y, f32 z) { return Scripting::SetObjectRotation(obj->Base, x, y, z); }
		static void SetObjectDynamic (GTA::GameObject^ object, b8 isdynamic) { return Scripting::SetObjectDynamic(object->Base, isdynamic); }
		static void SetObjectAsStealable (GTA::GameObject^ obj, b8 stealable) { return Scripting::SetObjectAsStealable(obj->Base, stealable); }
		static void SetObjectScale_NF (GTA::GameObject^ obj, f32 scale) { return Scripting::SetObjectScale_NF(obj->Base, scale); }

		// vehicle
		static void SetCarAsMissionCar (GTA::Vehicle^ v) { return Scripting::SetCarAsMissionCar(v->Base); }
		static void AttachCarToCarPhysically (GTA::Vehicle^ v1, GTA::Vehicle^ v2, b8 unk0, i32 unk1, f32 xoff, f32 yoff, f32 zoff, f32 xbuff, f32 ybuff, f32 zbuff, f32 unk2, f32 unk3, f32 unk4, f32 unk5, f32 unk6) { return Scripting::AttachCarToCarPhysically(v1->Base, v2->Base, unk0, unk1, xoff, yoff, zoff, xbuff, ybuff, zbuff, unk2, unk3, unk4, unk5, unk6); }
		static void AttachObjectToObjectPhysically (GTA::GameObject^ obj1, GTA::GameObject^ obj2, b8 unk0, i32 unk1, f32 xoff, f32 yoff, f32 zoff, f32 xbuff, f32 ybuff, f32 zbuff, f32 unk2, f32 unk3, f32 unk4, f32 unk5, f32 unk6) { return Scripting::AttachObjectToObjectPhysically(obj1->Base, obj2->Base, unk0, unk1, xoff, yoff, zoff, xbuff, ybuff, zbuff, unk2, unk3, unk4, unk5, unk6); }
		static void AttachObjectToCarPhysically (GTA::GameObject^ obj1, GTA::Vehicle^ v2, b8 unk0, i32 unk1, f32 xoff, f32 yoff, f32 zoff, f32 xbuff, f32 ybuff, f32 zbuff, f32 unk2, f32 unk3, f32 unk4, f32 unk5, f32 unk6) { return Scripting::AttachObjectToCarPhysically(obj1->Base, v2->Base, unk0, unk1, xoff, yoff, zoff, xbuff, ybuff, zbuff, unk2, unk3, unk4, unk5, unk6); }
		static void AttachObjectToObject (GTA::GameObject^ obj1, GTA::GameObject^ obj2, u32 unknown0_0, f32 pX, f32 pY, f32 pZ, f32 rX, f32 rY, f32 rZ) { return Scripting::AttachObjectToObject(obj1->Base, obj2->Base, unknown0_0, pX, pY, pZ, rX, rY, rZ); }
		static void AttachCarToCar (GTA::Vehicle^ car1, GTA::Vehicle^ car2, u32 unknown0_0, f32 pX, f32 pY, f32 pZ, f32 rX, f32 rY, f32 rZ) { return Scripting::AttachCarToCar(car1->Base, car2->Base, unknown0_0, pX, pY, pZ, rX, rY, rZ); }

		// ped
		static void SetCharCollision (GTA::Ped^ ped, b8 value) { return Scripting::SetCharCollision(ped->Base, value); }
		static void SetCharVisible (GTA::Ped^ ped, u8 value) { return Scripting::SetCharVisible(ped->Base, value); }
		static void SetPedAlpha (GTA::Ped^ ped, u32 alpha) { return Scripting::SetPedAlpha(ped->Base, alpha); }

		// model
		static void RequestCollisionForModel (GTA::eModel model) { return Scripting::RequestCollisionForModel((Scripting::eModel)model); }
		static b8 HasCollisionForModelLoaded (GTA::eModel model) { return Scripting::HasCollisionForModelLoaded((Scripting::eModel)model); }



		// network
		static int NetworkGetGameMode () { return Scripting::NetworkGetGameMode(); }
		static b8 HasControlOfNetworkId (u32 id) { return Scripting::HasControlOfNetworkId(id); }
		static b8 DoesObjectExistWithNetworkId (u32 id) { return Scripting::DoesObjectExistWithNetworkId(id); }
		static b8 DoesPedExistWithNetworkId (u32 id) { return Scripting::DoesPedExistWithNetworkId(id); }
		static b8 DoesVehicleExistWithNetworkId (u32 id) { return Scripting::DoesVehicleExistWithNetworkId(id); }

		static void GetObjectFromNetworkId (u32 id, GTA::GameObject^ obj) 
		 {
			Scripting::Object tmpobj;
			pin_ptr<Scripting::Object> pptmpobj = &tmpobj;
			Scripting::GetObjectFromNetworkId(id, pptmpobj);
			obj->Base = tmpobj;
		 }
		static void GetPedFromNetworkId (u32 id, GTA::Ped^ ped) { return Scripting::GetPedFromNetworkId(id, ped->Base); }
		static void GetVehicleFromNetworkId (u32 id, GTA::Vehicle^ car) { return Scripting::GetVehicleFromNetworkId(id, car->Base); }
		static void GetNetworkIdFromObject (GTA::GameObject^ obj, u32* id) { return Scripting::GetNetworkIdFromObject(obj->Base, id); }
		static void GetNetworkIdFromVehicle (GTA::Vehicle^ vehicle, u32* id) { return Scripting::GetNetworkIdFromVehicle(vehicle->Base, id); }
		static void GetNetworkIdFromPed (GTA::Ped^ ped, u32* id) { return Scripting::GetNetworkIdFromPed(ped->Base, id); }
		static b8 RequestControlOfNetworkId (u32 id) { return Scripting::RequestControlOfNetworkId(id); }
		static void SetNetworkIdCanMigrate (u32 id, b8 canmigrate) { return Scripting::SetNetworkIdCanMigrate(id, canmigrate); }
		static void SetNetworkIdExistsOnAllMachines (u32 id, b8 exists) { return Scripting::SetNetworkIdExistsOnAllMachines(id, exists); }
		static void SetNetworkIdStopCloning (u32 id, b8 unk_stop) { return Scripting::SetNetworkIdStopCloning(id, unk_stop); }
		static void NetworkKickPlayer (u32 networkID) { return Scripting::NetworkKickPlayer(networkID); }
		static void ForceNetPlayerInvisible_UNK2 (u32 unk_nid, b8 value) { return Scripting::ForceNetPlayerInvisible_UNK2(unk_nid, value); }




		// ---------------------------------------


	    // These are properly documented functions that were moved from ScriptingDirty.h and cleaned up
		// Beware... not all of them are tested.

		// If you need to add your own functions, add it to a separate file in your own project, not here!
		// This file may be updated very often as new functions are documented.

		// Player
		static void AddScore (GTA::Player^ playerIndex, i32 score) { return Scripting::AddScore(playerIndex->Base, score); }
		static void AllowPlayerToCarryNonMissionObjects (GTA::Player^ playerIndex, b8 allow) { return Scripting::AllowPlayerToCarryNonMissionObjects(playerIndex->Base, allow); }
		static void AlterWantedLevel (GTA::Player^ playerIndex, u32 level) { return Scripting::AlterWantedLevel(playerIndex->Base, level); }
		static void AlterWantedLevelNoDrop (GTA::Player^ playerIndex, u32 level) { return Scripting::AlterWantedLevelNoDrop(playerIndex->Base, level); }
		static void ApplyWantedLevelChangeNow (GTA::Player^ playerIndex) { return Scripting::ApplyWantedLevelChangeNow(playerIndex->Base); }
		static void ChangePlayerModel (GTA::Player^ playerIndex, GTA::eModel model) { return Scripting::ChangePlayerModel(playerIndex->Base, (Scripting::eModel)model); }
		static void ClearPlayerHasDamagedAtLeastOnePed (GTA::Player^ playerIndex) { return Scripting::ClearPlayerHasDamagedAtLeastOnePed(playerIndex->Base); }
		static GTA::Player^ ConvertIntToPlayerIndex (u32 playerId) { return gcnew GTA::Player( Scripting::ConvertIntToPlayerIndex(playerId)); }
		static void ClearWantedLevel (GTA::Player^ playerIndex) { return Scripting::ClearWantedLevel(playerIndex->Base); }
		static void CreatePlayer (u32 playerId, f32 x, f32 y, f32 z, GTA::Player^ pPlayerIndex) 
		 {
			Scripting::Player tmppPlayerIndex;
			pin_ptr<Scripting::Player> pptmppPlayerIndex = &tmppPlayerIndex;
			Scripting::CreatePlayer(playerId, x, y, z, pptmppPlayerIndex);
			pPlayerIndex->Base = tmppPlayerIndex;
		 }
		static void DisablePlayerLockon (GTA::Player^ playerIndex, b8 disabled) { return Scripting::DisablePlayerLockon(playerIndex->Base, disabled); }
		static void DisablePlayerSprint (GTA::Player^ playerIndex, b8 disabled) { return Scripting::DisablePlayerSprint(playerIndex->Base, disabled); }
		static void GetPlayerChar (GTA::Player^ playerIndex, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::GetPlayerChar(playerIndex->Base, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void GetPlayerGroup (GTA::Player^ playerIndex, GTA::Group^ pGroup) 
		 {
			Scripting::Group tmppGroup;
			pin_ptr<Scripting::Group> pptmppGroup = &tmppGroup;
			Scripting::GetPlayerGroup(playerIndex->Base, pptmppGroup);
			pGroup->Base = tmppGroup;
		 }
		static u32 GetPlayerId () { return Scripting::GetPlayerId(); }
		static void GetPlayersLastCarNoSave (GTA::Vehicle^ pVehicle) 
		 {
			Scripting::Vehicle tmppVehicle;
			pin_ptr<Scripting::Vehicle> pptmppVehicle = &tmppVehicle;
			Scripting::GetPlayersLastCarNoSave(pptmppVehicle);
			pVehicle->Base = tmppVehicle;
		 }
		static void GetPlayerMaxArmour (GTA::Player^ playerIndex, u32* pMaxArmour) { return Scripting::GetPlayerMaxArmour(playerIndex->Base, pMaxArmour); }
		//ConvertMe//    static constchr *GetPlayerName(Player playerIndex) { return NativeInvoke::Invoke<NATIVE_GET_PLAYER_NAME, constchr *>(playerIndex); }
		static GTA::eModel GetPlayerSettingsModelChoice () { return (GTA::eModel) Scripting::GetPlayerSettingsModelChoice(); }
		static Scripting::ScriptAny GetPlayerToPlaceBombInCar (GTA::Vehicle^ vehicle) { return Scripting::GetPlayerToPlaceBombInCar(vehicle->Base); }
		static u32 GetTimeSincePlayerDroveAgainstTraffic (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerDroveAgainstTraffic(playerIndex->Base); }
		static u32 GetTimeSincePlayerDroveOnPavement (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerDroveOnPavement(playerIndex->Base); }
		static u32 GetTimeSincePlayerHitBuilding (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerHitBuilding(playerIndex->Base); }
		static u32 GetTimeSincePlayerHitCar (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerHitCar(playerIndex->Base); }
		static u32 GetTimeSincePlayerHitObject (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerHitObject(playerIndex->Base); }
		static u32 GetTimeSincePlayerHitPed (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerHitPed(playerIndex->Base); }
		static u32 GetTimeSincePlayerRanLight (GTA::Player^ playerIndex) { return Scripting::GetTimeSincePlayerRanLight(playerIndex->Base); }
		static b8 HasPlayerCollectedPickup (GTA::Player^ playerIndex, GTA::Pickup^ pikcup) { return Scripting::HasPlayerCollectedPickup(playerIndex->Base, pikcup->Base); }
		static b8 HasPlayerDamagedAtLeastOnePed (GTA::Player^ playerIndex) { return Scripting::HasPlayerDamagedAtLeastOnePed(playerIndex->Base); }
		static b8 HasPlayerDamagedAtLeastOneVehicle (GTA::Player^ playerIndex) { return Scripting::HasPlayerDamagedAtLeastOneVehicle(playerIndex->Base); }
		static b8 IsPlayerClimbing (GTA::Player^ playerIndex) { return Scripting::IsPlayerClimbing(playerIndex->Base); }
		static b8 IsPlayerControlOn (GTA::Player^ playerIndex) { return Scripting::IsPlayerControlOn(playerIndex->Base); }
		static b8 IsPlayerDead (GTA::Player^ playerIndex) { return Scripting::IsPlayerDead(playerIndex->Base); }
		static b8 IsPlayerFreeAimingAtChar (GTA::Player^ playerIndex, GTA::Ped^ ped) { return Scripting::IsPlayerFreeAimingAtChar(playerIndex->Base, ped->Base); }
		static b8 IsPlayerFreeForAmbientTask (GTA::Player^ playerIndex) { return Scripting::IsPlayerFreeForAmbientTask(playerIndex->Base); }
		static b8 IsPlayerPlaying (GTA::Player^ playerIndex) { return Scripting::IsPlayerPlaying(playerIndex->Base); }
		static b8 IsPlayerPressingHorn (GTA::Player^ playerIndex) { return Scripting::IsPlayerPressingHorn(playerIndex->Base); }
		static b8 IsPlayerTargettingAnything (GTA::Player^ playerIndex) { return Scripting::IsPlayerTargettingAnything(playerIndex->Base); }
		static b8 IsPlayerTargettingChar (GTA::Player^ playerIndex, GTA::Ped^ ped) { return Scripting::IsPlayerTargettingChar(playerIndex->Base, ped->Base); }
		static b8 IsPlayerTargettingObject (GTA::Player^ playerIndex, GTA::GameObject^ obj) { return Scripting::IsPlayerTargettingObject(playerIndex->Base, obj->Base); }
		static b8 IsScoreGreater (GTA::Player^ playerIndex, u32 score) { return Scripting::IsScoreGreater(playerIndex->Base, score); }
		static b8 IsWantedLevelGreater (GTA::Player^ playerIndex, u32 level) { return Scripting::IsWantedLevelGreater(playerIndex->Base, level); }
		static b8 PlayerHasChar (GTA::Player^ playerIndex) { return Scripting::PlayerHasChar(playerIndex->Base); }
		static b8 PlayerHasFlashingStarsAboutToDrop (GTA::Player^ playerIndex) { return Scripting::PlayerHasFlashingStarsAboutToDrop(playerIndex->Base); }
		static b8 PlayerHasGreyedOutStars (GTA::Player^ playerIndex) { return Scripting::PlayerHasGreyedOutStars(playerIndex->Base); }
		static void RegisterPlayerRespawnCoords (GTA::Player^ playerIndex, f32 x, f32 y, f32 z) { return Scripting::RegisterPlayerRespawnCoords(playerIndex->Base, x, y, z); }
		static void SetEveryoneIgnorePlayer (GTA::Player^ playerIndex, b8 value) { return Scripting::SetEveryoneIgnorePlayer(playerIndex->Base, value); }
		static void SetPlayerCanBeHassledByGangs (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerCanBeHassledByGangs(playerIndex->Base, value); }
		static void SetPlayerCanDoDriveBy (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerCanDoDriveBy(playerIndex->Base, value); }
		static void SetPlayerCanUseCover (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerCanUseCover(playerIndex->Base, value); }
		static void SetPlayerControl (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerControl(playerIndex->Base, value); }
		static void SetPlayerControlAdvanced (GTA::Player^ playerIndex, b8 unknown1, b8 unknown2, b8 unknown3) { return Scripting::SetPlayerControlAdvanced(playerIndex->Base, unknown1, unknown2, unknown3); }
		static void SetPlayerFastReload (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerFastReload(playerIndex->Base, value); }
		static void SetPlayerGroupToFollowAlways (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerGroupToFollowAlways(playerIndex->Base, value); }
		static void SetPlayerInvincible (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerInvincible(playerIndex->Base, value); }
		static void SetPlayerMoodNormal (GTA::Player^ playerIndex) { return Scripting::SetPlayerMoodNormal(playerIndex->Base); }
		static void SetPlayerMoodPissedOff (GTA::Player^ playerIndex, u32 unknown150) { return Scripting::SetPlayerMoodPissedOff(playerIndex->Base, unknown150); }
		static void SetPlayerNeverGetsTired (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPlayerNeverGetsTired(playerIndex->Base, value); }
		static void SetPlayerSettingsModelVariationsChoice (GTA::Player^ playerIndex) { return Scripting::SetPlayerSettingsModelVariationsChoice(playerIndex->Base); }
		static void SetPoliceIgnorePlayer (GTA::Player^ playerIndex, b8 value) { return Scripting::SetPoliceIgnorePlayer(playerIndex->Base, value); }
		static void StoreScore (GTA::Player^ playerIndex, u32* value) { return Scripting::StoreScore(playerIndex->Base, value); }
		static void StoreWantedLevel (GTA::Player^ playerIndex, u32* value) { return Scripting::StoreWantedLevel(playerIndex->Base, value); }
		static void RemovePlayerHelmet (GTA::Player^ playerIndex, b8 remove) { return Scripting::RemovePlayerHelmet(playerIndex->Base, remove); }

		// Ped
		static void AddAmmoToChar (GTA::Ped^ ped, GTA::eWeapon weapon, u32 amount) { return Scripting::AddAmmoToChar(ped->Base, (Scripting::eWeapon)weapon, amount); }
		static void AddArmourToChar (GTA::Ped^ ped, u32 amount) { return Scripting::AddArmourToChar(ped->Base, amount); }
		static void ApplyForceToPed (GTA::Ped^ ped, u32 unknown0_3, f32 x, f32 y, f32 z, f32 spinX, f32 spinY, f32 spinZ, u32 unknown4_0, u32 unknown5_1, u32 unknown6_1, u32 unknown7_1) { return Scripting::ApplyForceToPed(ped->Base, unknown0_3, x, y, z, spinX, spinY, spinZ, unknown4_0, unknown5_1, unknown6_1, unknown7_1); }
		static void AttachPedToCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 unknown0_0, f32 offsetX, f32 offsetY, f32 offsetZ, f32 unknown1_276, f32 unknown2_0, u32 unknown3_0, u32 unknown4_0) { return Scripting::AttachPedToCar(ped->Base, vehicle->Base, unknown0_0, offsetX, offsetY, offsetZ, unknown1_276, unknown2_0, unknown3_0, unknown4_0); }
		static void BlockCharGestureAnims (GTA::Ped^ ped, b8 value) { return Scripting::BlockCharGestureAnims(ped->Base, value); }
		static void BlockPedWeaponSwitching (GTA::Ped^ ped, b8 value) { return Scripting::BlockPedWeaponSwitching(ped->Base, value); }
		static void CancelCurrentlyPlayingAmbientSpeech (GTA::Ped^ ped) { return Scripting::CancelCurrentlyPlayingAmbientSpeech(ped->Base); }
		static void ClearAllCharProps (GTA::Ped^ ped) { return Scripting::ClearAllCharProps(ped->Base); }
		static void ClearCharLastDamageBone (GTA::Ped^ ped) { return Scripting::ClearCharLastDamageBone(ped->Base); }
		static void ClearCharLastDamageEntity (GTA::Ped^ ped) { return Scripting::ClearCharLastDamageEntity(ped->Base); }
		static void ClearCharLastWeaponDamage (GTA::Ped^ ped) { return Scripting::ClearCharLastWeaponDamage(ped->Base); }
		static void ClearCharProp (GTA::Ped^ ped, b8 unknown) { return Scripting::ClearCharProp(ped->Base, unknown); }
		static void ClearCharSecondaryTask (GTA::Ped^ ped) { return Scripting::ClearCharSecondaryTask(ped->Base); }
		static void ClearCharTasks (GTA::Ped^ ped) { return Scripting::ClearCharTasks(ped->Base); }
		static void ClearCharTasksImmediately (GTA::Ped^ ped) { return Scripting::ClearCharTasksImmediately(ped->Base); }
		static void ClearRoomForChar (GTA::Ped^ ped) { return Scripting::ClearRoomForChar(ped->Base); }
		static void CreateChar (u32 type, GTA::eModel model, f32 x, f32 y, f32 z, GTA::Ped^ pPed, b8 unknownTrue) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateChar(type, (Scripting::eModel)model, x, y, z, pptmppPed, unknownTrue);
			pPed->Base = tmppPed;
		 }
		static void CreateRandomChar (f32 x, f32 y, f32 z, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateRandomChar(x, y, z, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void CreateRandomCharAsDriver (GTA::Vehicle^ vehicle, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateRandomCharAsDriver(vehicle->Base, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void CreateRandomFemaleChar (f32 x, f32 y, f32 z, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateRandomFemaleChar(x, y, z, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void CreateRandomMaleChar (f32 x, f32 y, f32 z, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateRandomMaleChar(x, y, z, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void DamageChar (GTA::Ped^ ped, u32 hitPoints, b8 unknown) { return Scripting::DamageChar(ped->Base, hitPoints, unknown); }
		static void DamagePedBodyPart (GTA::Ped^ ped, GTA::ePedBodyPart part, u32 hitPoints) { return Scripting::DamagePedBodyPart(ped->Base, (Scripting::ePedBodyPart)part, hitPoints); }
		static void DeleteChar (GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::DeleteChar(pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void DetachPed (GTA::Ped^ ped, b8 unknown) { return Scripting::DetachPed(ped->Base, unknown); }
		static void DetachPedFromWithinCar (GTA::Ped^ ped, b8 unknown) { return Scripting::DetachPedFromWithinCar(ped->Base, unknown); }
		static b8 DoesCharExist (GTA::Ped^ ped) { return Scripting::DoesCharExist(ped->Base); }
		static void DropObject (GTA::Ped^ ped, b8 unknownTrue) { return Scripting::DropObject(ped->Base, unknownTrue); }
		static void ExplodeCharHead (GTA::Ped^ ped) { return Scripting::ExplodeCharHead(ped->Base); }
		static void ExtinguishCharFire (GTA::Ped^ ped) { return Scripting::ExtinguishCharFire(ped->Base); }
		static void FirePedWeapon (GTA::Ped^ ped, f32 x, f32 y, f32 z) { return Scripting::FirePedWeapon(ped->Base, x, y, z); }
		static void ForceCharToDropWeapon (GTA::Ped^ ped) { return Scripting::ForceCharToDropWeapon(ped->Base); }
		static Scripting::ScriptAny ForcePedPinnedDown (GTA::Ped^ ped, b8 force, u32 timerMaybe) { return Scripting::ForcePedPinnedDown(ped->Base, force, timerMaybe); }
		static void ForcePedToFleeWhilstDrivingVehicle (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::ForcePedToFleeWhilstDrivingVehicle(ped->Base, vehicle->Base); }
		static void FreezeCharPosition (GTA::Ped^ ped, b8 frozen) { return Scripting::FreezeCharPosition(ped->Base, frozen); }
		static void FreezeCharPositionAndDontLoadCollision (GTA::Ped^ ped, b8 frozen) { return Scripting::FreezeCharPositionAndDontLoadCollision(ped->Base, frozen); }
		static void GetAmmoInCharWeapon (GTA::Ped^ ped, GTA::eWeapon weapon, u32* pAmmo) { return Scripting::GetAmmoInCharWeapon(ped->Base, (Scripting::eWeapon)weapon, pAmmo); }
		static b8 GetAmmoInClip (GTA::Ped^ ped, GTA::eWeapon weapon, u32* pAmmo) { return Scripting::GetAmmoInClip(ped->Base, (Scripting::eWeapon)weapon, pAmmo); }
		//ConvertMe//    static constchr *GetAnimGroupFromChar(Ped ped) { return NativeInvoke::Invoke<NATIVE_GET_ANIM_GROUP_FROM_CHAR, constchr *>(ped); }
		static void GetCharCoordinates (GTA::Ped^ ped, f32* pX, f32* pY, f32* pZ) { return Scripting::GetCharCoordinates(ped->Base, pX, pY, pZ); }
		static void GetCharHealth (GTA::Ped^ ped, u32* pHealth) { return Scripting::GetCharHealth(ped->Base, pHealth); }
		static void GetCharAnimCurrentTime (GTA::Ped^ ped, String^ animGroup, String^ animName, f32* pValue) 
		 {
			marshal_context^ conanimGroup = gcnew marshal_context();;
			const char* canimGroup = conanimGroup->marshal_as<const char*>(animGroup);
			marshal_context^ conanimName = gcnew marshal_context();;
			const char* canimName = conanimName->marshal_as<const char*>(animName);
			Scripting::GetCharAnimCurrentTime(ped->Base, canimGroup, canimName, pValue);
			delete conanimGroup;
		 delete conanimName;
		 }
		static void GetCharAnimTotalTime (GTA::Ped^ ped, String^ animGroup, String^ animName, f32* pValue) 
		 {
			marshal_context^ conanimGroup = gcnew marshal_context();;
			const char* canimGroup = conanimGroup->marshal_as<const char*>(animGroup);
			marshal_context^ conanimName = gcnew marshal_context();;
			const char* canimName = conanimName->marshal_as<const char*>(animName);
			Scripting::GetCharAnimTotalTime(ped->Base, canimGroup, canimName, pValue);
			delete conanimGroup;
		 delete conanimName;
		 }
		static void GetCharArmour (GTA::Ped^ ped, u32* pArmour) { return Scripting::GetCharArmour(ped->Base, pArmour); }
		static u32 GetCharDrawableVariation (GTA::Ped^ ped, GTA::ePedComponent component) { return Scripting::GetCharDrawableVariation(ped->Base, (Scripting::ePedComponent)component); }
		static void GetCharExtractedDisplacement (GTA::Ped^ ped, b8 unknown, f32* pX, f32* pY, f32* pZ) { return Scripting::GetCharExtractedDisplacement(ped->Base, unknown, pX, pY, pZ); }
		static void GetCharHeading (GTA::Ped^ ped, f32* pValue) { return Scripting::GetCharHeading(ped->Base, pValue); }
		static void GetCharHeightAboveGround (GTA::Ped^ ped, f32* pValue) { return Scripting::GetCharHeightAboveGround(ped->Base, pValue); }
		static Scripting::ScriptAny GetCharLastDamageBone (GTA::Ped^ ped, GTA::ePedBone* pBone) { return Scripting::GetCharLastDamageBone(ped->Base, (Scripting::ePedBone*)pBone); }
		static b8 GetCharMeleeActionFlag0 (GTA::Ped^ ped) { return Scripting::GetCharMeleeActionFlag0(ped->Base); }
		static b8 GetCharMeleeActionFlag1 (GTA::Ped^ ped) { return Scripting::GetCharMeleeActionFlag1(ped->Base); }
		static void GetCharModel (GTA::Ped^ ped, GTA::eModel* pModel) { return Scripting::GetCharModel(ped->Base, (Scripting::eModel*)pModel); }
		static u32 GetCharMoney (GTA::Ped^ ped) { return Scripting::GetCharMoney(ped->Base); }
		static void GetCharPropIndex (GTA::Ped^ ped, b8 unknown, u32* pIndex) { return Scripting::GetCharPropIndex(ped->Base, unknown, pIndex); }
		static b8 GetCharReadyToBeExecuted (GTA::Ped^ ped) { return Scripting::GetCharReadyToBeExecuted(ped->Base); }
		static b8 GetCharReadyToBeStunned (GTA::Ped^ ped) { return Scripting::GetCharReadyToBeStunned(ped->Base); }
		static void GetCharSpeed (GTA::Ped^ ped, f32* pValue) { return Scripting::GetCharSpeed(ped->Base, pValue); }
		static u32 GetCharTextureVariation (GTA::Ped^ ped, GTA::ePedComponent component) { return Scripting::GetCharTextureVariation(ped->Base, (Scripting::ePedComponent)component); }
		static void GetCharVelocity (GTA::Ped^ ped, f32* pX, f32* pY, f32* pZ) { return Scripting::GetCharVelocity(ped->Base, pX, pY, pZ); }
		static void GetCharWeaponInSlot (GTA::Ped^ ped, GTA::eWeaponSlot slot, GTA::eWeapon* pWeapon, Scripting::ScriptAny* pUnknown1, Scripting::ScriptAny* pUnknown2) { return Scripting::GetCharWeaponInSlot(ped->Base, (Scripting::eWeaponSlot)slot, (Scripting::eWeapon*)pWeapon, pUnknown1, pUnknown2); }
		static b8 GetCharWillCowerInsteadOfFleeing (GTA::Ped^ ped) { return Scripting::GetCharWillCowerInsteadOfFleeing(ped->Base); }
		static Scripting::ScriptAny GetCurrentCharWeapon (GTA::Ped^ ped, GTA::eWeapon* pWeapon) { return Scripting::GetCurrentCharWeapon(ped->Base, (Scripting::eWeapon*)pWeapon); }
		static u32 GetDamageToPedBodyPart (GTA::Ped^ ped, GTA::ePedBodyPart part) { return Scripting::GetDamageToPedBodyPart(ped->Base, (Scripting::ePedBodyPart)part); }
		static void GetDeadCharCoordinates (GTA::Ped^ ped, f32* pX, f32* pY, f32* pZ) { return Scripting::GetDeadCharCoordinates(ped->Base, pX, pY, pZ); }
		static void GetDeadCharPickupCoords (GTA::Ped^ ped, f32* pX, f32* pY, f32* pZ) { return Scripting::GetDeadCharPickupCoords(ped->Base, pX, pY, pZ); }
		static void GetKeyForCharInRoom (GTA::Ped^ ped, GTA::eInteriorRoomKey* pKey) { return Scripting::GetKeyForCharInRoom(ped->Base, (Scripting::eInteriorRoomKey*)pKey); }
		static Scripting::ScriptAny GetMaxAmmo (GTA::Ped^ ped, GTA::eWeapon weapon, u32* pMaxAmmo) { return Scripting::GetMaxAmmo(ped->Base, (Scripting::eWeapon)weapon, pMaxAmmo); }
		static void GetMaxAmmoInClip (GTA::Ped^ ped, GTA::eWeapon weapon, u32* pMaxAmmo) { return Scripting::GetMaxAmmoInClip(ped->Base, (Scripting::eWeapon)weapon, pMaxAmmo); }
		static u32 GetNumberOfCharDrawableVariations (GTA::Ped^ ped, GTA::ePedComponent component) { return Scripting::GetNumberOfCharDrawableVariations(ped->Base, (Scripting::ePedComponent)component); }
		static u32 GetNumberOfCharTextureVariations (GTA::Ped^ ped, GTA::ePedComponent component, u32 unknown1) { return Scripting::GetNumberOfCharTextureVariations(ped->Base, (Scripting::ePedComponent)component, unknown1); }
		static GTA::GameObject^ GetObjectPedIsHolding (GTA::Ped^ ped) { return gcnew GTA::GameObject( Scripting::GetObjectPedIsHolding(ped->Base)); }
		static void GetOffsetFromCharInWorldCoords (GTA::Ped^ ped, f32 x, f32 y, f32 z, f32* pOffX, f32* pOffY, f32* pOffZ) { return Scripting::GetOffsetFromCharInWorldCoords(ped->Base, x, y, z, pOffX, pOffY, pOffZ); }
		static GTA::ePedClimbState GetPedClimbState (GTA::Ped^ ped) { return (GTA::ePedClimbState) Scripting::GetPedClimbState(ped->Base); }
		static void GetPedBonePosition (GTA::Ped^ ped, GTA::ePedBone bone, f32 x, f32 y, f32 z, GTA::Vector3^ pPosition) 
		 {
			Scripting::Vector3 tmppPosition;
			pin_ptr<Scripting::Vector3> pptmppPosition = &tmppPosition;
			Scripting::GetPedBonePosition(ped->Base, (Scripting::ePedBone)bone, x, y, z, pptmppPosition);
			pPosition->Base = &tmppPosition;
		 }
		static void GetPedGroupIndex (GTA::Ped^ ped, u32* pIndex) { return Scripting::GetPedGroupIndex(ped->Base, pIndex); }
		static void GetPedType (GTA::Ped^ ped, GTA::ePedType* pType) { return Scripting::GetPedType(ped->Base, (Scripting::ePedType*)pType); }
		static void GivePedHelmet (GTA::Ped^ ped) { return Scripting::GivePedHelmet(ped->Base); }
		static void GiveWeaponToChar (GTA::Ped^ ped, GTA::eWeapon weapon, u32 ammo, b8 unknown0) { return Scripting::GiveWeaponToChar(ped->Base, (Scripting::eWeapon)weapon, ammo, unknown0); }
		static b8 HasCharBeenDamagedByCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::HasCharBeenDamagedByCar(ped->Base, vehicle->Base); }
		static b8 HasCharBeenDamagedByChar (GTA::Ped^ ped, GTA::Ped^ otherChar, b8 unknownFalse) { return Scripting::HasCharBeenDamagedByChar(ped->Base, otherChar->Base, unknownFalse); }
		static b8 HasCharBeenDamagedByWeapon (GTA::Ped^ ped, GTA::eWeapon weapon) { return Scripting::HasCharBeenDamagedByWeapon(ped->Base, (Scripting::eWeapon)weapon); }
		static b8 HasCharGotWeapon (GTA::Ped^ ped, GTA::eWeapon weapon) { return Scripting::HasCharGotWeapon(ped->Base, (Scripting::eWeapon)weapon); }
		static b8 HasCharSpottedChar (GTA::Ped^ ped, GTA::Ped^ otherChar) { return Scripting::HasCharSpottedChar(ped->Base, otherChar->Base); }
		static b8 HasCharSpottedCharInFront (GTA::Ped^ ped, GTA::Ped^ otherChar) { return Scripting::HasCharSpottedCharInFront(ped->Base, otherChar->Base); }
		static b8 IsAmbientSpeechPlaying (GTA::Ped^ ped) { return Scripting::IsAmbientSpeechPlaying(ped->Base); }
		static b8 IsCharArmed (GTA::Ped^ ped, GTA::eWeaponSlot slot) { return Scripting::IsCharArmed(ped->Base, (Scripting::eWeaponSlot)slot); }
		static b8 IsCharDead (GTA::Ped^ ped) { return Scripting::IsCharDead(ped->Base); }
		static b8 IsCharDucking (GTA::Ped^ ped) { return Scripting::IsCharDucking(ped->Base); }
		static b8 IsCharFacingChar (GTA::Ped^ ped, GTA::Ped^ otherChar, f32 angle) { return Scripting::IsCharFacingChar(ped->Base, otherChar->Base, angle); }
		static b8 IsCharFatallyInjured (GTA::Ped^ ped) { return Scripting::IsCharFatallyInjured(ped->Base); }
		static b8 IsCharGesturing (GTA::Ped^ ped) { return Scripting::IsCharGesturing(ped->Base); }
		static b8 IsCharGettingInToACar (GTA::Ped^ ped) { return Scripting::IsCharGettingInToACar(ped->Base); }
		static b8 IsCharGettingUp (GTA::Ped^ ped) { return Scripting::IsCharGettingUp(ped->Base); }
		static b8 IsCharHealthGreater (GTA::Ped^ ped, u32 health) { return Scripting::IsCharHealthGreater(ped->Base, health); }
		static b8 IsCharInAir (GTA::Ped^ ped) { return Scripting::IsCharInAir(ped->Base); }
		static b8 IsCharInAngledArea2D (GTA::Ped^ ped, f32 x1, f32 y1, f32 x2, f32 y2, f32 unknown, b8 unknownFalse) { return Scripting::IsCharInAngledArea2D(ped->Base, x1, y1, x2, y2, unknown, unknownFalse); }
		static b8 IsCharInAngledArea3D (GTA::Ped^ ped, f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, f32 unknown, b8 unknownFalse) { return Scripting::IsCharInAngledArea3D(ped->Base, x1, y1, z1, x2, y2, z2, unknown, unknownFalse); }
		static b8 IsCharInAnyBoat (GTA::Ped^ ped) { return Scripting::IsCharInAnyBoat(ped->Base); }
		static b8 IsCharInAnyCar (GTA::Ped^ ped) { return Scripting::IsCharInAnyCar(ped->Base); }
		static b8 IsCharInAnyHeli (GTA::Ped^ ped) { return Scripting::IsCharInAnyHeli(ped->Base); }
		static b8 IsCharInAnyPlane (GTA::Ped^ ped) { return Scripting::IsCharInAnyPlane(ped->Base); }
		static b8 IsCharInAnyPoliceVehicle (GTA::Ped^ ped) { return Scripting::IsCharInAnyPoliceVehicle(ped->Base); }
		static b8 IsCharInAnyTrain (GTA::Ped^ ped) { return Scripting::IsCharInAnyTrain(ped->Base); }
		static b8 IsCharInArea2D (GTA::Ped^ ped, f32 x1, f32 y1, f32 x2, f32 y2, b8 unknownFalse) { return Scripting::IsCharInArea2D(ped->Base, x1, y1, x2, y2, unknownFalse); }
		static b8 IsCharInArea3D (GTA::Ped^ ped, f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, b8 unknownFalse) { return Scripting::IsCharInArea3D(ped->Base, x1, y1, z1, x2, y2, z2, unknownFalse); }
		static b8 IsCharInAreaOnFoot2D (GTA::Ped^ ped, f32 x1, f32 y1, f32 x2, f32 y2, b8 unknownFalse) { return Scripting::IsCharInAreaOnFoot2D(ped->Base, x1, y1, x2, y2, unknownFalse); }
		static b8 IsCharInCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::IsCharInCar(ped->Base, vehicle->Base); }
		static b8 IsCharInFlyingVehicle (GTA::Ped^ ped) { return Scripting::IsCharInFlyingVehicle(ped->Base); }
		static b8 IsCharInMeleeCombat (GTA::Ped^ ped) { return Scripting::IsCharInMeleeCombat(ped->Base); }
		static b8 IsCharInModel (GTA::Ped^ ped, GTA::eModel model) { return Scripting::IsCharInModel(ped->Base, (Scripting::eModel)model); }
		static b8 IsCharInTaxi (GTA::Ped^ ped) { return Scripting::IsCharInTaxi(ped->Base); }
		static b8 IsCharInWater (GTA::Ped^ ped) { return Scripting::IsCharInWater(ped->Base); }
		static b8 IsCharInjured (GTA::Ped^ ped) { return Scripting::IsCharInjured(ped->Base); }
		static b8 IsCharMale (GTA::Ped^ ped) { return Scripting::IsCharMale(ped->Base); }
		static b8 IsCharModel (GTA::Ped^ ped, GTA::eModel model) { return Scripting::IsCharModel(ped->Base, (Scripting::eModel)model); }
		static b8 IsCharOnAnyBike (GTA::Ped^ ped) { return Scripting::IsCharOnAnyBike(ped->Base); }
		static b8 IsCharOnFire (GTA::Ped^ ped) { return Scripting::IsCharOnFire(ped->Base); }
		static b8 IsCharOnFoot (GTA::Ped^ ped) { return Scripting::IsCharOnFoot(ped->Base); }
		static b8 IsCharOnScreen (GTA::Ped^ ped) { return Scripting::IsCharOnScreen(ped->Base); }
		static b8 IsCharPlayingAnim (GTA::Ped^ ped, String^ animSet, String^ animName) 
		 {
			char* canimSet = (char*)Marshal::StringToHGlobalAnsi(animSet).ToPointer();
			char* canimName = (char*)Marshal::StringToHGlobalAnsi(animName).ToPointer();
			b8 retval = Scripting::IsCharPlayingAnim(ped->Base, canimSet, canimName);
			 Marshal::FreeHGlobal((IntPtr)canimSet);
		  Marshal::FreeHGlobal((IntPtr)canimName);
		 return retval;
		 }
		static b8 IsCharShooting (GTA::Ped^ ped) { return Scripting::IsCharShooting(ped->Base); }
		static b8 IsCharShootingInArea (GTA::Ped^ ped, f32 x1, f32 y1, f32 x2, f32 y2, b8 unknownFalse) { return Scripting::IsCharShootingInArea(ped->Base, x1, y1, x2, y2, unknownFalse); }
		static b8 IsCharSittingIdle (GTA::Ped^ ped) { return Scripting::IsCharSittingIdle(ped->Base); }
		static b8 IsCharSittingInAnyCar (GTA::Ped^ ped) { return Scripting::IsCharSittingInAnyCar(ped->Base); }
		static b8 IsCharSittingInCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::IsCharSittingInCar(ped->Base, vehicle->Base); }
		static b8 IsCharStopped (GTA::Ped^ ped) { return Scripting::IsCharStopped(ped->Base); }
		static b8 IsCharStuckUnderCar (GTA::Ped^ ped) { return Scripting::IsCharStuckUnderCar(ped->Base); }
		static b8 IsCharSwimming (GTA::Ped^ ped) { return Scripting::IsCharSwimming(ped->Base); }
		static b8 IsCharTouchingChar (GTA::Ped^ ped, GTA::Ped^ otherChar) { return Scripting::IsCharTouchingChar(ped->Base, otherChar->Base); }
		static b8 IsCharTouchingObject (GTA::Ped^ ped, GTA::GameObject^ obj) { return Scripting::IsCharTouchingObject(ped->Base, obj->Base); }
		static b8 IsCharTouchingObjectOnFoot (GTA::Ped^ ped, GTA::GameObject^ obj) { return Scripting::IsCharTouchingObjectOnFoot(ped->Base, obj->Base); }
		static b8 IsCharTouchingVehicle (Scripting::ScriptAny p0, Scripting::ScriptAny p1) { return Scripting::IsCharTouchingVehicle(p0, p1); }
		static b8 IsCharTryingToEnterALockedCar (GTA::Ped^ ped) { return Scripting::IsCharTryingToEnterALockedCar(ped->Base); }
		static b8 IsCharUsingAnyScenario (GTA::Ped^ ped) { return Scripting::IsCharUsingAnyScenario(ped->Base); }
		static b8 IsCharUsingScenario (GTA::Ped^ ped, String^ scenarioName) 
		 {
			marshal_context^ conscenarioName = gcnew marshal_context();;
			const char* cscenarioName = conscenarioName->marshal_as<const char*>(scenarioName);
			b8 retval = Scripting::IsCharUsingScenario(ped->Base, cscenarioName);
			delete conscenarioName;
		 return retval;
		 }
		static b8 IsCharVisible (GTA::Ped^ ped) { return Scripting::IsCharVisible(ped->Base); }
		static b8 IsCharWaitingForWorldCollision (GTA::Ped^ ped) { return Scripting::IsCharWaitingForWorldCollision(ped->Base); }
		static b8 IsPedAMissionPed (GTA::Ped^ ped) { return Scripting::IsPedAMissionPed(ped->Base); }
		static b8 IsPedAttachedToAnyCar (GTA::Ped^ ped) { return Scripting::IsPedAttachedToAnyCar(ped->Base); }
		static b8 IsPedAttachedToObject (GTA::Ped^ ped, GTA::GameObject^ obj) { return Scripting::IsPedAttachedToObject(ped->Base, obj->Base); }
		static b8 IsPedBeingJacked (GTA::Ped^ ped) { return Scripting::IsPedBeingJacked(ped->Base); }
		static b8 IsPedDoingDriveby (GTA::Ped^ ped) { return Scripting::IsPedDoingDriveby(ped->Base); }
		static b8 IsPedFleeing (GTA::Ped^ ped) { return Scripting::IsPedFleeing(ped->Base); }
		static b8 IsPedHoldingAnObject (GTA::Ped^ ped) { return Scripting::IsPedHoldingAnObject(ped->Base); }
		static b8 IsPedInCombat (GTA::Ped^ ped) { return Scripting::IsPedInCombat(ped->Base); }
		static b8 IsPedInCover (GTA::Ped^ ped) { return Scripting::IsPedInCover(ped->Base); }
		static b8 IsPedInGroup (GTA::Ped^ ped) { return Scripting::IsPedInGroup(ped->Base); }
		static b8 IsPedJacking (GTA::Ped^ ped) { return Scripting::IsPedJacking(ped->Base); }
		static b8 IsPedLookingAtPed (GTA::Ped^ ped, GTA::Ped^ otherChar) { return Scripting::IsPedLookingAtPed(ped->Base, otherChar->Base); }
		static b8 IsPedRagdoll (GTA::Ped^ ped) { return Scripting::IsPedRagdoll(ped->Base); }
		static b8 IsPedRetreating (GTA::Ped^ ped) { return Scripting::IsPedRetreating(ped->Base); }
		static b8 IsScriptedSpeechPlaying (GTA::Ped^ ped) { return Scripting::IsScriptedSpeechPlaying(ped->Base); }
		static void MarkCharAsNoLongerNeeded (GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::MarkCharAsNoLongerNeeded(pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void ModifyCharMoveState (GTA::Ped^ ped, GTA::ePedMoveState state) { return Scripting::ModifyCharMoveState(ped->Base, (Scripting::ePedMoveState)state); }
		static void RemoveAllCharWeapons (GTA::Ped^ ped) { return Scripting::RemoveAllCharWeapons(ped->Base); }
		static void RemoveCharDefensiveArea (GTA::Ped^ ped) { return Scripting::RemoveCharDefensiveArea(ped->Base); }
		static void RemoveCharElegantly (GTA::Ped^ ped) { return Scripting::RemoveCharElegantly(ped->Base); }
		static void RemoveCharFromGroup (GTA::Ped^ ped) { return Scripting::RemoveCharFromGroup(ped->Base); }
		static void ReviveInjuredPed (GTA::Ped^ ped) { return Scripting::ReviveInjuredPed(ped->Base); }
		static void SayAmbientSpeech (GTA::Ped^ ped, String^ phraseName, Scripting::ScriptAny unknown0_1, Scripting::ScriptAny unknown1_1, Scripting::ScriptAny unknown2_0) 
		 {
			char* cphraseName = (char*)Marshal::StringToHGlobalAnsi(phraseName).ToPointer();
			Scripting::SayAmbientSpeech(ped->Base, cphraseName, unknown0_1, unknown1_1, unknown2_0);
			 Marshal::FreeHGlobal((IntPtr)cphraseName);
		 }
		static Scripting::ScriptAny SetAmmoInClip (GTA::Ped^ ped, GTA::eWeapon weapon, u32 ammo) { return Scripting::SetAmmoInClip(ped->Base, (Scripting::eWeapon)weapon, ammo); }
		static void SetBlockingOfNonTemporaryEvents (GTA::Ped^ ped, b8 value) { return Scripting::SetBlockingOfNonTemporaryEvents(ped->Base, value); }
		static void SetCharAccuracy (GTA::Ped^ ped, u32 value) { return Scripting::SetCharAccuracy(ped->Base, value); }
		static void SetCharAmmo (GTA::Ped^ ped, GTA::eWeapon weapon, u32 ammo) { return Scripting::SetCharAmmo(ped->Base, (Scripting::eWeapon)weapon, ammo); }
		static void SetCharAsEnemy (GTA::Ped^ ped, b8 value) { return Scripting::SetCharAsEnemy(ped->Base, value); }
		static void SetCharAsMissionChar (GTA::Ped^ ped) { return Scripting::SetCharAsMissionChar(ped->Base); }
		static void SetCharCanBeKnockedOffBike (GTA::Ped^ ped, b8 value) { return Scripting::SetCharCanBeKnockedOffBike(ped->Base, value); }
		static void SetCharCanBeShotInVehicle (GTA::Ped^ ped, b8 enabled) { return Scripting::SetCharCanBeShotInVehicle(ped->Base, enabled); }
		static void SetCharCantBeDraggedOut (GTA::Ped^ ped, b8 enabled) { return Scripting::SetCharCantBeDraggedOut(ped->Base, enabled); }
		static void SetCharComponentVariation (GTA::Ped^ ped, GTA::ePedComponent component, u32 modelVariation, u32 textureVariation) { return Scripting::SetCharComponentVariation(ped->Base, (Scripting::ePedComponent)component, modelVariation, textureVariation); }
		static void SetCharCoordinates (GTA::Ped^ ped, f32 x, f32 y, f32 z) { return Scripting::SetCharCoordinates(ped->Base, x, y, z); }
		static void SetCharDefaultComponentVariation (GTA::Ped^ ped) { return Scripting::SetCharDefaultComponentVariation(ped->Base); }
		static void SetCharDesiredHeading (GTA::Ped^ ped, f32 heading) { return Scripting::SetCharDesiredHeading(ped->Base, heading); }
		static void SetCharDropsWeaponsWhenDead (GTA::Ped^ ped, b8 value) { return Scripting::SetCharDropsWeaponsWhenDead(ped->Base, value); }
		static void SetCharDruggedUp (GTA::Ped^ ped, b8 drugged) { return Scripting::SetCharDruggedUp(ped->Base, drugged); }
		static void SetCharFireDamageMultiplier (GTA::Ped^ ped, f32 multiplier) { return Scripting::SetCharFireDamageMultiplier(ped->Base, multiplier); }
		static void SetCharGravity (GTA::Ped^ ped, f32 value) { return Scripting::SetCharGravity(ped->Base, value); }
		static void SetCharHeading (GTA::Ped^ ped, f32 heading) { return Scripting::SetCharHeading(ped->Base, heading); }
		static void SetCharHealth (GTA::Ped^ ped, u32 health) { return Scripting::SetCharHealth(ped->Base, health); }
		static void SetCharInvincible (GTA::Ped^ ped, b8 enable) { return Scripting::SetCharInvincible(ped->Base, enable); }
		static void SetCharIsTargetPriority (GTA::Ped^ ped, b8 enable) { return Scripting::SetCharIsTargetPriority(ped->Base, enable); }
		static void SetCharMaxHealth (GTA::Ped^ ped, u32 value) { return Scripting::SetCharMaxHealth(ped->Base, value); }
		static void SetCharMoney (GTA::Ped^ ped, u32 amount) { return Scripting::SetCharMoney(ped->Base, amount); }
		static void SetCharNeverLeavesGroup (GTA::Ped^ ped, b8 value) { return Scripting::SetCharNeverLeavesGroup(ped->Base, value); }
		static void SetCharProofs (GTA::Ped^ ped, b8 unknown0, b8 fallingDamage, b8 unknown1, b8 unknown2, b8 unknown3) { return Scripting::SetCharProofs(ped->Base, unknown0, fallingDamage, unknown1, unknown2, unknown3); }
		static void SetCharPropIndex (GTA::Ped^ ped, GTA::ePedPropType propType, u32 index) { return Scripting::SetCharPropIndex(ped->Base, (Scripting::ePedPropType)propType, index); }
		static void SetCharRandomComponentVariation (GTA::Ped^ ped) { return Scripting::SetCharRandomComponentVariation(ped->Base); }
		static void SetCharSphereDefensiveArea (GTA::Ped^ ped, f32 x, f32 y, f32 z, f32 radius) { return Scripting::SetCharSphereDefensiveArea(ped->Base, x, y, z, radius); }
		static void SetCharSuffersCriticalHits (GTA::Ped^ ped, b8 value) { return Scripting::SetCharSuffersCriticalHits(ped->Base, value); }
		static void SetCharVelocity (GTA::Ped^ ped, f32 x, f32 y, f32 z) { return Scripting::SetCharVelocity(ped->Base, x, y, z); }
		static void SetCharVisible (GTA::Ped^ ped, b8 value) { return Scripting::SetCharVisible(ped->Base, value); }
		static void SetCharWantedByPolice (GTA::Ped^ ped, b8 wanted) { return Scripting::SetCharWantedByPolice(ped->Base, wanted); }
		static void SetCharWillDoDrivebys (GTA::Ped^ ped, b8 value) { return Scripting::SetCharWillDoDrivebys(ped->Base, value); }
		static void SetCharWillFlyThroughWindscreen (GTA::Ped^ ped, b8 value) { return Scripting::SetCharWillFlyThroughWindscreen(ped->Base, value); }
		static void SetCharWillMoveWhenInjured (GTA::Ped^ ped, b8 value) { return Scripting::SetCharWillMoveWhenInjured(ped->Base, value); }
		static void SetCharWillUseCarsInCombat (GTA::Ped^ ped, b8 value) { return Scripting::SetCharWillUseCarsInCombat(ped->Base, value); }
		static void SetCharWillUseCover (GTA::Ped^ ped, GTA::CoverPoint^ coverPoint) { return Scripting::SetCharWillUseCover(ped->Base, coverPoint->Base); }
		static void SetCurrentCharWeapon (GTA::Ped^ ped, GTA::eWeapon w, b8 unknownTrue) { return Scripting::SetCurrentCharWeapon(ped->Base, (Scripting::eWeapon)w, unknownTrue); }
		static void SetGroupCharDucksWhenAimedAt (GTA::Ped^ ped, b8 value) { return Scripting::SetGroupCharDucksWhenAimedAt(ped->Base, value); }
		static void SetIgnoreLowPriorityShockingEvents (GTA::Ped^ ped, b8 value) { return Scripting::SetIgnoreLowPriorityShockingEvents(ped->Base, value); }
		static void SetPedDiesWhenInjured (GTA::Ped^ ped, b8 value) { return Scripting::SetPedDiesWhenInjured(ped->Base, value); }
		static void SetPedIsBlindRaging (GTA::Ped^ ped, b8 value) { return Scripting::SetPedIsBlindRaging(ped->Base, value); }
		static void SetPedIsDrunk (GTA::Ped^ ped, b8 value) { return Scripting::SetPedIsDrunk(ped->Base, value); }
		static void SetPedPathMayDropFromHeight (GTA::Ped^ ped, b8 value) { return Scripting::SetPedPathMayDropFromHeight(ped->Base, value); }
		static void SetPedPathMayUseClimbovers (GTA::Ped^ ped, b8 value) { return Scripting::SetPedPathMayUseClimbovers(ped->Base, value); }
		static void SetPedPathMayUseLadders (GTA::Ped^ ped, b8 value) { return Scripting::SetPedPathMayUseLadders(ped->Base, value); }
		static void SetRoomForCharByKey (GTA::Ped^ ped, GTA::eInteriorRoomKey key) { return Scripting::SetRoomForCharByKey(ped->Base, (Scripting::eInteriorRoomKey)key); }
		static void SetSenseRange (GTA::Ped^ ped, f32 value) { return Scripting::SetSenseRange(ped->Base, value); }
		static void SwitchPedToAnimated (GTA::Ped^ ped, b8 unknownTrue) { return Scripting::SwitchPedToAnimated(ped->Base, unknownTrue); }
		static Scripting::ScriptAny SwitchPedToRagdoll (GTA::Ped^ ped, Scripting::ScriptAny p1, Scripting::ScriptAny p2, Scripting::ScriptAny p3, Scripting::ScriptAny p4, Scripting::ScriptAny p5, Scripting::ScriptAny p6) { return Scripting::SwitchPedToRagdoll(ped->Base, p1, p2, p3, p4, p5, p6); }
		static void RemovePedHelmet (GTA::Ped^ ped, b8 removed) { return Scripting::RemovePedHelmet(ped->Base, removed); }
		static void RemoveWeaponFromChar (GTA::Ped^ ped, GTA::eWeapon weapon) { return Scripting::RemoveWeaponFromChar(ped->Base, (Scripting::eWeapon)weapon); }
		static void UnlockRagdoll (GTA::Ped^ ped, b8 value) { return Scripting::UnlockRagdoll(ped->Base, value); }
		static void WarpCharFromCarToCoord (GTA::Ped^ ped, f32 x, f32 y, f32 z) { return Scripting::WarpCharFromCarToCoord(ped->Base, x, y, z); }
		static void WarpCharIntoCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::WarpCharIntoCar(ped->Base, vehicle->Base); }
		static void WarpCharIntoCarAsPassenger (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 seatIndex) { return Scripting::WarpCharIntoCarAsPassenger(ped->Base, vehicle->Base, seatIndex); }
		static void WarpCharFromCarToCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 seatIndex) { return Scripting::WarpCharFromCarToCar(ped->Base, vehicle->Base, seatIndex); }


		// Ped Tasks
		static void SetCharKeepTask (GTA::Ped^ ped, b8 value) { return Scripting::SetCharKeepTask(ped->Base, value); }
		static void SetDriveTaskCruiseSpeed (GTA::Ped^ ped, f32 speed) { return Scripting::SetDriveTaskCruiseSpeed(ped->Base, speed); }
		static void TaskAchieveHeading (GTA::Ped^ ped, f32 heading) { return Scripting::TaskAchieveHeading(ped->Base, heading); }
		static void TaskAimGunAtChar (GTA::Ped^ ped, GTA::Ped^ targetPed, u32 duration) { return Scripting::TaskAimGunAtChar(ped->Base, targetPed->Base, duration); }
		static void TaskAimGunAtCoord (GTA::Ped^ ped, f32 tX, f32 tY, f32 tZ, u32 duration) { return Scripting::TaskAimGunAtCoord(ped->Base, tX, tY, tZ, duration); }
		static void TaskCarDriveWander (GTA::Ped^ ped, GTA::Vehicle^ vehicle, f32 speed, GTA::eVehicleDrivingStyle drivingStyle) { return Scripting::TaskCarDriveWander(ped->Base, vehicle->Base, speed, (Scripting::eVehicleDrivingStyle)drivingStyle); }
		static void TaskCarMission (GTA::Ped^ ped, GTA::Vehicle^ vehicle, GTA::ScriptHandle^ targetEntity, u32 missionType, f32 speed, GTA::eVehicleDrivingStyle drivingStyle, u32 unknown6_10, u32 unknown7_5) { return Scripting::TaskCarMission(ped->Base, vehicle->Base, targetEntity->Base, missionType, speed, (Scripting::eVehicleDrivingStyle)drivingStyle, unknown6_10, unknown7_5); }
		static void TaskCarMissionNotAgainstTraffic (GTA::Ped^ ped, GTA::Vehicle^ vehicle, GTA::ScriptHandle^ targetEntity, u32 missionType, f32 speed, GTA::eVehicleDrivingStyle style, u32 unknown6_10, u32 unknown7_5) { return Scripting::TaskCarMissionNotAgainstTraffic(ped->Base, vehicle->Base, targetEntity->Base, missionType, speed, (Scripting::eVehicleDrivingStyle)style, unknown6_10, unknown7_5); }
		static void TaskCarMissionCoorsTarget (GTA::Ped^ ped, GTA::Vehicle^ vehicle, f32 x, f32 y, f32 z, u32 unknown0_4, f32 speed, u32 unknown2_1, u32 unknown3_5, u32 unknown4_10) { return Scripting::TaskCarMissionCoorsTarget(ped->Base, vehicle->Base, x, y, z, unknown0_4, speed, unknown2_1, unknown3_5, unknown4_10); }
		static void TaskCarMissionCoorsTargetNotAgainstTraffic (GTA::Ped^ ped, GTA::Vehicle^ vehicle, f32 x, f32 y, f32 z, u32 unknown0_4, f32 speed, u32 unknown2_1, u32 unknown3_5, u32 unknown4_10) { return Scripting::TaskCarMissionCoorsTargetNotAgainstTraffic(ped->Base, vehicle->Base, x, y, z, unknown0_4, speed, unknown2_1, unknown3_5, unknown4_10); }
		static void TaskCarMissionPedTarget (GTA::Ped^ ped, GTA::Vehicle^ vehicle, GTA::Ped^ target, u32 unknown0_4, f32 speed, u32 unknown2_1, u32 unknown3_5, u32 unknown4_10) { return Scripting::TaskCarMissionPedTarget(ped->Base, vehicle->Base, target->Base, unknown0_4, speed, unknown2_1, unknown3_5, unknown4_10); }
		static void TaskCarTempAction (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 action, u32 duration) { return Scripting::TaskCarTempAction(ped->Base, vehicle->Base, action, duration); }
		static void TaskCombat (GTA::Ped^ ped, GTA::Ped^ target) { return Scripting::TaskCombat(ped->Base, target->Base); }
		static void TaskCombatHatedTargetsAroundChar (GTA::Ped^ ped, f32 radius) { return Scripting::TaskCombatHatedTargetsAroundChar(ped->Base, radius); }
		static void TaskCombatHatedTargetsAroundCharTimed (GTA::Ped^ ped, f32 radius, u32 duration) { return Scripting::TaskCombatHatedTargetsAroundCharTimed(ped->Base, radius, duration); }
		static void TaskCombatTimed (GTA::Ped^ ped, Scripting::Char target, u32 duration) { return Scripting::TaskCombatTimed(ped->Base, target, duration); }
		static void TaskDie (GTA::Ped^ ped) { return Scripting::TaskDie(ped->Base); }
		static void TaskEnterCarAsDriver (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 duration) { return Scripting::TaskEnterCarAsDriver(ped->Base, vehicle->Base, duration); }
		static void TaskEnterCarAsPassenger (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 duration, u32 seatIndex) { return Scripting::TaskEnterCarAsPassenger(ped->Base, vehicle->Base, duration, seatIndex); }
		static void TaskEveryoneLeaveCar (GTA::Vehicle^ vehicle) { return Scripting::TaskEveryoneLeaveCar(vehicle->Base); }
		static void TaskFollowNavMeshToCoord (GTA::Ped^ ped, f32 x, f32 y, f32 z, u32 unknown0_2, u32 unknown1_minus1, f32 unknown2_1) { return Scripting::TaskFollowNavMeshToCoord(ped->Base, x, y, z, unknown0_2, unknown1_minus1, unknown2_1); }
		static void TaskFollowNavMeshToCoordNoStop (GTA::Ped^ ped, f32 x, f32 y, f32 z, u32 unknown0_2, u32 unknown1_minus1, f32 unknown2_1) { return Scripting::TaskFollowNavMeshToCoordNoStop(ped->Base, x, y, z, unknown0_2, unknown1_minus1, unknown2_1); }
		static void TaskGoStraightToCoord (GTA::Ped^ ped, f32 x, f32 y, f32 z, u32 unknown2, u32 unknown45000) { return Scripting::TaskGoStraightToCoord(ped->Base, x, y, z, unknown2, unknown45000); }
		static void TaskGotoCharOffset (GTA::Ped^ ped, GTA::Ped^ target, u32 duration, f32 offsetRight, f32 offsetFront) { return Scripting::TaskGotoCharOffset(ped->Base, target->Base, duration, offsetRight, offsetFront); }
		static void TaskGuardCurrentPosition (GTA::Ped^ ped, f32 unknown0_15, f32 unknown1_10, u32 unknown2_1) { return Scripting::TaskGuardCurrentPosition(ped->Base, unknown0_15, unknown1_10, unknown2_1); }
		static void TaskHandsUp (GTA::Ped^ ped, u32 duration) { return Scripting::TaskHandsUp(ped->Base, duration); }
		static void TaskHeliMission (GTA::Ped^ ped, GTA::Vehicle^ heli, u32 uk0_0, u32 uk1_0, f32 pX, f32 pY, f32 pZ, u32 uk2_4, f32 speed, u32 uk3_5, f32 uk4_minus1, u32 uk5_round_z_plus_1, u32 uk6_40) { return Scripting::TaskHeliMission(ped->Base, heli->Base, uk0_0, uk1_0, pX, pY, pZ, uk2_4, speed, uk3_5, uk4_minus1, uk5_round_z_plus_1, uk6_40); }
		static void TaskLeaveAnyCar (GTA::Ped^ ped) { return Scripting::TaskLeaveAnyCar(ped->Base); }
		static void TaskLeaveCar (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::TaskLeaveCar(ped->Base, vehicle->Base); }
		static void TaskLeaveCarDontCloseDoor (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::TaskLeaveCarDontCloseDoor(ped->Base, vehicle->Base); }
		static void TaskLeaveCarImmediately (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::TaskLeaveCarImmediately(ped->Base, vehicle->Base); }
		static void TaskLookAtChar (GTA::Ped^ ped, GTA::Ped^ targetPed, u32 duration, u32 unknown_0) { return Scripting::TaskLookAtChar(ped->Base, targetPed->Base, duration, unknown_0); }
		static void TaskLookAtCoord (GTA::Ped^ ped, f32 x, f32 y, f32 z, u32 duration, u32 unknown_0) { return Scripting::TaskLookAtCoord(ped->Base, x, y, z, duration, unknown_0); }
		static void TaskLookAtObject (GTA::Ped^ ped, GTA::GameObject^ targetObject, u32 duration, u32 unknown_0) { return Scripting::TaskLookAtObject(ped->Base, targetObject->Base, duration, unknown_0); }
		static void TaskLookAtVehicle (GTA::Ped^ ped, GTA::Vehicle^ targetVehicle, u32 duration, u32 unknown_0) { return Scripting::TaskLookAtVehicle(ped->Base, targetVehicle->Base, duration, unknown_0); }
		static void TaskOpenDriverDoor (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 unknown0) { return Scripting::TaskOpenDriverDoor(ped->Base, vehicle->Base, unknown0); }
		static void TaskOpenPassengerDoor (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 seatIndex, u32 unknown0) { return Scripting::TaskOpenPassengerDoor(ped->Base, vehicle->Base, seatIndex, unknown0); }
		static void TaskPause (GTA::Ped^ ped, u32 duration) { return Scripting::TaskPause(ped->Base, duration); }
		static void TaskPlayAnimWithFlags (GTA::Ped^ ped, String^ animName, String^ animSet, f32 unknown0_8, u32 unknown1_0, u32 flags) 
		 {
			marshal_context^ conanimName = gcnew marshal_context();;
			const char* canimName = conanimName->marshal_as<const char*>(animName);
			marshal_context^ conanimSet = gcnew marshal_context();;
			const char* canimSet = conanimSet->marshal_as<const char*>(animSet);
			Scripting::TaskPlayAnimWithFlags(ped->Base, canimName, canimSet, unknown0_8, unknown1_0, flags);
			delete conanimName;
		 delete conanimSet;
		 }
		static void TaskSetCharDecisionMaker (GTA::Ped^ ped, GTA::DecisionMaker^ dm) { return Scripting::TaskSetCharDecisionMaker(ped->Base, dm->Base); }
		static void TaskSetCombatDecisionMaker (GTA::Ped^ ped, GTA::DecisionMaker^ dm) { return Scripting::TaskSetCombatDecisionMaker(ped->Base, dm->Base); }
		static void TaskSmartFleeChar (GTA::Ped^ ped, GTA::Ped^ fleeFromPed, f32 unknown0_100, u32 duration) { return Scripting::TaskSmartFleeChar(ped->Base, fleeFromPed->Base, unknown0_100, duration); }
		static void TaskSmartFleeCharPreferringPavements (GTA::Ped^ ped, GTA::Ped^ fleeFromPed, f32 unknown0_100, u32 duration) { return Scripting::TaskSmartFleeCharPreferringPavements(ped->Base, fleeFromPed->Base, unknown0_100, duration); }
		static void TaskSmartFleePoint (GTA::Ped^ ped, f32 x, f32 y, f32 z, f32 unknown0_100, u32 duration) { return Scripting::TaskSmartFleePoint(ped->Base, x, y, z, unknown0_100, duration); }
		static void TaskStandStill (GTA::Ped^ ped, int duration) { return Scripting::TaskStandStill(ped->Base, duration); }
		static void TaskSwapWeapon (GTA::Ped^ ped, GTA::eWeapon weapon) { return Scripting::TaskSwapWeapon(ped->Base, (Scripting::eWeapon)weapon); }
		static void TaskTurnCharToFaceChar (GTA::Ped^ ped, GTA::Ped^ targetPed) { return Scripting::TaskTurnCharToFaceChar(ped->Base, targetPed->Base); }
		static void TaskTurnCharToFaceCoord (GTA::Ped^ ped, f32 x, f32 y, f32 z) { return Scripting::TaskTurnCharToFaceCoord(ped->Base, x, y, z); }
		static void TaskUseMobilePhone (GTA::Ped^ ped, b8 use) { return Scripting::TaskUseMobilePhone(ped->Base, use); }
		static void TaskUseMobilePhoneTimed (GTA::Ped^ ped, u32 duration) { return Scripting::TaskUseMobilePhoneTimed(ped->Base, duration); }
		static void TaskWanderStandard (GTA::Ped^ ped) { return Scripting::TaskWanderStandard(ped->Base); }
		static void TaskWarpCharIntoCarAsDriver (GTA::Ped^ ped, GTA::Vehicle^ vehicle) { return Scripting::TaskWarpCharIntoCarAsDriver(ped->Base, vehicle->Base); }
		static void TaskWarpCharIntoCarAsPassenger (GTA::Ped^ ped, GTA::Vehicle^ vehicle, u32 seatIndex) { return Scripting::TaskWarpCharIntoCarAsPassenger(ped->Base, vehicle->Base, seatIndex); }

		// Task Sequence
		static void OpenSequenceTask (GTA::TaskSequence^ pTaskSequence) 
		 {
			Scripting::TaskSequence tmppTaskSequence;
			pin_ptr<Scripting::TaskSequence> pptmppTaskSequence = &tmppTaskSequence;
			Scripting::OpenSequenceTask(pptmppTaskSequence);
			pTaskSequence->Base = tmppTaskSequence;
		 }
		static void CloseSequenceTask (GTA::TaskSequence^ taskSequence) { return Scripting::CloseSequenceTask(taskSequence->Base); }
		static void TaskPerformSequence (GTA::Ped^ ped, GTA::TaskSequence^ taskSequence) { return Scripting::TaskPerformSequence(ped->Base, taskSequence->Base); }
		static void ClearSequenceTask (GTA::TaskSequence^ taskSequence) { return Scripting::ClearSequenceTask(taskSequence->Base); }

		// Ped Search
		static void AllowScenarioPedsToBeReturnedByNextCommand (b8 value) { return Scripting::AllowScenarioPedsToBeReturnedByNextCommand(value); }
		static void BeginCharSearchCriteria () { return Scripting::BeginCharSearchCriteria(); }
		static void EndCharSearchCriteria () { return Scripting::EndCharSearchCriteria(); }
		static b8 GetClosestChar (f32 x, f32 y, f32 z, f32 radius, u32 unknown1, u32 unknown2, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			b8 retval = Scripting::GetClosestChar(x, y, z, radius, unknown1, unknown2, pptmppPed);
			pPed->Base = tmppPed;
		 return retval;
		 }
		static void GetRandomCharInAreaOffsetNoSave (f32 x, f32 y, f32 z, f32 sx, f32 sy, f32 sz, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::GetRandomCharInAreaOffsetNoSave(x, y, z, sx, sy, sz, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void SearchCriteriaConsiderPedsWithFlagTrue (u32 flagId) { return Scripting::SearchCriteriaConsiderPedsWithFlagTrue(flagId); }
		static void SearchCriteriaRejectPedsWithFlagTrue (u32 flagId) { return Scripting::SearchCriteriaRejectPedsWithFlagTrue(flagId); }

		// Ped Groups
		static void CreateGroup (b8 unknownFalse, GTA::Group^ pGroup, b8 unknownTrue) 
		 {
			Scripting::Group tmppGroup;
			pin_ptr<Scripting::Group> pptmppGroup = &tmppGroup;
			Scripting::CreateGroup(unknownFalse, pptmppGroup, unknownTrue);
			pGroup->Base = tmppGroup;
		 }
		static b8 DoesGroupExist (GTA::Group^ group) { return Scripting::DoesGroupExist(group->Base); }
		static void GetGroupLeader (GTA::Group^ group, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::GetGroupLeader(group->Base, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void GetGroupMember (GTA::Group^ group, u32 index, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::GetGroupMember(group->Base, index, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void GetGroupSize (GTA::Group^ group, u32* pStartIndex, u32* pCount) { return Scripting::GetGroupSize(group->Base, pStartIndex, pCount); }
		static b8 IsGroupLeader (GTA::Ped^ ped, GTA::Group^ group) { return Scripting::IsGroupLeader(ped->Base, group->Base); }
		static b8 IsGroupMember (GTA::Ped^ ped, GTA::Group^ g) { return Scripting::IsGroupMember(ped->Base, g->Base); }
		static void RemoveGroup (GTA::Group^ group) { return Scripting::RemoveGroup(group->Base); }
		static void SetGroupFollowStatus (GTA::Group^ group, u32 status) { return Scripting::SetGroupFollowStatus(group->Base, status); }
		static void SetGroupFormation (GTA::Group^ group, u32 formation) { return Scripting::SetGroupFormation(group->Base, formation); }
		static void SetGroupFormationSpacing (GTA::Group^ group, f32 space) { return Scripting::SetGroupFormationSpacing(group->Base, space); }
		static void SetGroupLeader (GTA::Group^ group, GTA::Ped^ leader) { return Scripting::SetGroupLeader(group->Base, leader->Base); }
		static void SetGroupMember (GTA::Group^ group, GTA::Ped^ member) { return Scripting::SetGroupMember(group->Base, member->Base); }
		static void SetGroupSeparationRange (GTA::Group^ group, f32 seperation) { return Scripting::SetGroupSeparationRange(group->Base, seperation); }

		// Ped Relationships
		static void AllowGangRelationshipsToBeChangedByNextCommand (b8 value) { return Scripting::AllowGangRelationshipsToBeChangedByNextCommand(value); }
		static void SetCharNotDamagedByRelationshipGroup (GTA::Ped^ ped, u32 relationshipGroup, b8 enable) { return Scripting::SetCharNotDamagedByRelationshipGroup(ped->Base, relationshipGroup, enable); }
		static void SetCharRelationship (GTA::Ped^ ped, u32 relationshipLevel, u32 relationshipGroup) { return Scripting::SetCharRelationship(ped->Base, relationshipLevel, relationshipGroup); }
		static void SetCharRelationshipGroup (GTA::Ped^ ped, u32 relationshipGroup) { return Scripting::SetCharRelationshipGroup(ped->Base, relationshipGroup); }
		static void SetRelationship (u32 relationshipLevel, u32 relationshipGroup1, u32 relationshipGroup2) { return Scripting::SetRelationship(relationshipLevel, relationshipGroup1, relationshipGroup2); }

		// Vehicle
		static void AddUpsideDownCarCheck (GTA::Vehicle^ vehicle) { return Scripting::AddUpsideDownCarCheck(vehicle->Base); }
		static void AnchorBoat (GTA::Vehicle^ boat, b8 anchor) { return Scripting::AnchorBoat(boat->Base, anchor); }
		static void ApplyForceToCar (GTA::Vehicle^ vehicle, u32 unknown0_3, f32 x, f32 y, f32 z, f32 spinX, f32 spinY, f32 spinZ, u32 unknown4_0, u32 unknown5_1, u32 unknown6_1, u32 unknown7_1) { return Scripting::ApplyForceToCar(vehicle->Base, unknown0_3, x, y, z, spinX, spinY, spinZ, unknown4_0, unknown5_1, unknown6_1, unknown7_1); }
		static b8 AreTaxiLightsOn (GTA::Vehicle^ vehicle) { return Scripting::AreTaxiLightsOn(vehicle->Base); }
		static void BreakCarDoor (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door, b8 unknownFalse) { return Scripting::BreakCarDoor(vehicle->Base, (Scripting::eVehicleDoor)door, unknownFalse); }
		static void BurstCarTyre (GTA::Vehicle^ vehicle, GTA::eVehicleTyre tyre) { return Scripting::BurstCarTyre(vehicle->Base, (Scripting::eVehicleTyre)tyre); }
		static void CreateCar (u32 nameHash, f32 x, f32 y, f32 z, GTA::Vehicle^ pVehicle, b8 unknownTrue) 
		 {
			Scripting::Vehicle tmppVehicle;
			pin_ptr<Scripting::Vehicle> pptmppVehicle = &tmppVehicle;
			Scripting::CreateCar(nameHash, x, y, z, pptmppVehicle, unknownTrue);
			pVehicle->Base = tmppVehicle;
		 }
		static void CreateCharAsPassenger (GTA::Vehicle^ vehicle, GTA::ePedType charType, GTA::eModel model, u32 passengerIndex, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateCharAsPassenger(vehicle->Base, (Scripting::ePedType)charType, (Scripting::eModel)model, passengerIndex, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void CreateCharInsideCar (GTA::Vehicle^ vehicle, GTA::ePedType charType, GTA::eModel model, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateCharInsideCar(vehicle->Base, (Scripting::ePedType)charType, (Scripting::eModel)model, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void ChangeCarColour (GTA::Vehicle^ vehicle, Scripting::ColourIndex colour1, Scripting::ColourIndex colour2) { return Scripting::ChangeCarColour(vehicle->Base, colour1, colour2); }
		static void ClearCarLastDamageEntity (GTA::Vehicle^ vehicle) { return Scripting::ClearCarLastDamageEntity(vehicle->Base); }
		static void ClearCarLastWeaponDamage (GTA::Vehicle^ vehicle) { return Scripting::ClearCarLastWeaponDamage(vehicle->Base); }
		static void ClearRoomForCar (GTA::Vehicle^ vehicle) { return Scripting::ClearRoomForCar(vehicle->Base); }
		static void CloseAllCarDoors (GTA::Vehicle^ vehicle) { return Scripting::CloseAllCarDoors(vehicle->Base); }
		static void ControlCarDoor (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door, u32 unknown_maybe_open, f32 angle) { return Scripting::ControlCarDoor(vehicle->Base, (Scripting::eVehicleDoor)door, unknown_maybe_open, angle); }
		static b8 CreateEmergencyServicesCar (GTA::eModel model, f32 x, f32 y, f32 z) { return Scripting::CreateEmergencyServicesCar((Scripting::eModel)model, x, y, z); }
		static void CreateRandomCharAsPassenger (GTA::Vehicle^ vehicle, u32 seat, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::CreateRandomCharAsPassenger(vehicle->Base, seat, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static void DeleteCar (GTA::Vehicle^ pVehicle) 
		 {
			Scripting::Vehicle tmppVehicle;
			pin_ptr<Scripting::Vehicle> pptmppVehicle = &tmppVehicle;
			Scripting::DeleteCar(pptmppVehicle);
			pVehicle->Base = tmppVehicle;
		 }
		static void DetachCar (GTA::Vehicle^ vehicle) { return Scripting::DetachCar(vehicle->Base); }
		static b8 DoesCarHaveRoof (GTA::Vehicle^ vehicle) { return Scripting::DoesCarHaveRoof(vehicle->Base); }
		static b8 DoesCarHaveStuckCarCheck (GTA::Vehicle^ vehicle) { return Scripting::DoesCarHaveStuckCarCheck(vehicle->Base); }
		static b8 DoesVehicleExist (GTA::Vehicle^ vehicle) { return Scripting::DoesVehicleExist(vehicle->Base); }
		static void EnablePedHelmet (GTA::Ped^ ped, b8 enable) { return Scripting::EnablePedHelmet(ped->Base, enable); }
		static void ExplodeCar (GTA::Vehicle^ vehicle, b8 unknownTrue, b8 unknownFalse) { return Scripting::ExplodeCar(vehicle->Base, unknownTrue, unknownFalse); }
		static void ExtinguishCarFire (GTA::Vehicle^ vehicle) { return Scripting::ExtinguishCarFire(vehicle->Base); }
		static void FixCar (GTA::Vehicle^ vehicle) { return Scripting::FixCar(vehicle->Base); }
		static void FixCarTyre (GTA::Vehicle^ vehicle, GTA::eVehicleTyre tyre) { return Scripting::FixCarTyre(vehicle->Base, (Scripting::eVehicleTyre)tyre); }
		static void ForceVehicleLights (GTA::Vehicle^ vehicle, GTA::eVehicleLights lights) { return Scripting::ForceVehicleLights(vehicle->Base, (Scripting::eVehicleLights)lights); }
		static void FreezeCarPosition (GTA::Vehicle^ vehicle, b8 frozen) { return Scripting::FreezeCarPosition(vehicle->Base, frozen); }
		static void FreezeCarPositionAndDontLoadCollision (GTA::Vehicle^ vehicle, b8 frozen) { return Scripting::FreezeCarPositionAndDontLoadCollision(vehicle->Base, frozen); }
		static void GetCarCharIsUsing (GTA::Ped^ ped, GTA::Vehicle^ pVehicle) 
		 {
			Scripting::Vehicle tmppVehicle;
			pin_ptr<Scripting::Vehicle> pptmppVehicle = &tmppVehicle;
			Scripting::GetCarCharIsUsing(ped->Base, pptmppVehicle);
			pVehicle->Base = tmppVehicle;
		 }
		static void GetCarColours (GTA::Vehicle^ vehicle, Scripting::ColourIndex* pColour1, Scripting::ColourIndex* pColour2) { return Scripting::GetCarColours(vehicle->Base, pColour1, pColour2); }
		static void GetCarCoordinates (GTA::Vehicle^ vehicle, f32* pX, f32* pY, f32* pZ) { return Scripting::GetCarCoordinates(vehicle->Base, pX, pY, pZ); }
		static void GetCarDeformationAtPos (GTA::Vehicle^ vehicle, f32 x, f32 y, f32 z, GTA::Vector3^ pDeformation) 
		 {
			Scripting::Vector3 tmppDeformation;
			pin_ptr<Scripting::Vector3> pptmppDeformation = &tmppDeformation;
			Scripting::GetCarDeformationAtPos(vehicle->Base, x, y, z, pptmppDeformation);
			pDeformation->Base = &tmppDeformation;
		 }
		static void GetCarDoorLockStatus (GTA::Vehicle^ vehicle, GTA::eVehicleDoorLock* pValue) { return Scripting::GetCarDoorLockStatus(vehicle->Base, (Scripting::eVehicleDoorLock*)pValue); }
		static void GetCarForwardX (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarForwardX(vehicle->Base, pValue); }
		static void GetCarForwardY (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarForwardY(vehicle->Base, pValue); }
		static void GetCarHeading (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarHeading(vehicle->Base, pValue); }
		static void GetCarHealth (GTA::Vehicle^ vehicle, u32* pValue) { return Scripting::GetCarHealth(vehicle->Base, pValue); }
		static void GetCarModel (GTA::Vehicle^ vehicle, GTA::eModel* pValue) { return Scripting::GetCarModel(vehicle->Base, (Scripting::eModel*)pValue); }
		static void GetCarPitch (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarPitch(vehicle->Base, pValue); }
		static void GetCarRoll (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarRoll(vehicle->Base, pValue); }
		static void GetCarSpeed (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarSpeed(vehicle->Base, pValue); }
		static void GetCarSpeedVector (GTA::Vehicle^ vehicle, GTA::Vector3^ pVector, b8 unknownFalse) 
		 {
			Scripting::Vector3 tmppVector;
			pin_ptr<Scripting::Vector3> pptmppVector = &tmppVector;
			Scripting::GetCarSpeedVector(vehicle->Base, pptmppVector, unknownFalse);
			pVector->Base = &tmppVector;
		 }
		static void GetCarUprightValue (GTA::Vehicle^ vehicle, f32* pValue) { return Scripting::GetCarUprightValue(vehicle->Base, pValue); }
		static void GetCharInCarPassengerSeat (GTA::Vehicle^ vehicle, u32 seatIndex, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::GetCharInCarPassengerSeat(vehicle->Base, seatIndex, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static GTA::Vehicle^ GetClosestCar (f32 x, f32 y, f32 z, f32 radius, u32 unknown0_0, u32 unknown1_70) { return gcnew GTA::Vehicle( Scripting::GetClosestCar(x, y, z, radius, unknown0_0, unknown1_70)); }
		static b8 GetClosestCarNode (f32 x, f32 y, f32 z, f32* pResX, f32* pResY, f32* pResZ) { return Scripting::GetClosestCarNode(x, y, z, pResX, pResY, pResZ); }
		static b8 GetClosestCarNodeWithHeading (f32 x, f32 y, f32 z, f32* pResX, f32* pResY, f32* pResZ, f32* pHeading) { return Scripting::GetClosestCarNodeWithHeading(x, y, z, pResX, pResY, pResZ, pHeading); }
		static b8 GetClosestMajorCarNode (f32 x, f32 y, f32 z, f32* pResX, f32* pResY, f32* pResZ) { return Scripting::GetClosestMajorCarNode(x, y, z, pResX, pResY, pResZ); }
		static b8 GetNthClosestCarNodeWithHeading (f32 x, f32 y, f32 z, u32 nodeNum, f32* pResX, f32* pResY, f32* pResZ, f32* pHeading) { return Scripting::GetNthClosestCarNodeWithHeading(x, y, z, nodeNum, pResX, pResY, pResZ, pHeading); }
		static b8 GetNthClosestCarNodeWithHeadingOnIsland (f32 x, f32 y, f32 z, u32 nodeNum, u32 areaId, f32* pResX, f32* pResY, f32* pResZ, f32* pHeading, u32* pUnknownMaybeAreaId) { return Scripting::GetNthClosestCarNodeWithHeadingOnIsland(x, y, z, nodeNum, areaId, pResX, pResY, pResZ, pHeading, pUnknownMaybeAreaId); }
		static void GetDeadCarCoordinates (GTA::Vehicle^ vehicle, f32* pX, f32* pY, f32* pZ) { return Scripting::GetDeadCarCoordinates(vehicle->Base, pX, pY, pZ); }
		static void GetDoorAngleRatio (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door, f32* pAngleRatio) { return Scripting::GetDoorAngleRatio(vehicle->Base, (Scripting::eVehicleDoor)door, pAngleRatio); }
		static void GetDriverOfCar (GTA::Vehicle^ vehicle, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			Scripting::GetDriverOfCar(vehicle->Base, pptmppPed);
			pPed->Base = tmppPed;
		 }
		static f32 GetEngineHealth (GTA::Vehicle^ vehicle) { return Scripting::GetEngineHealth(vehicle->Base); }
		static void GetExtraCarColours (GTA::Vehicle^ vehicle, Scripting::ColourIndex* pColour1, Scripting::ColourIndex* pColour2) { return Scripting::GetExtraCarColours(vehicle->Base, pColour1, pColour2); }
		static f32 GetHeightOfVehicle (GTA::Vehicle^ vehicle, f32 x, f32 y, f32 z, b8 unknownTrue1, b8 unknownTrue2) { return Scripting::GetHeightOfVehicle(vehicle->Base, x, y, z, unknownTrue1, unknownTrue2); }
		static void GetKeyForCarInRoom (GTA::Vehicle^ vehicle, u32* pKey) { return Scripting::GetKeyForCarInRoom(vehicle->Base, pKey); }
		static void GetMaximumNumberOfPassengers (GTA::Vehicle^ vehicle, u32* pMax) { return Scripting::GetMaximumNumberOfPassengers(vehicle->Base, pMax); }
		static void GetNearestCableCar (f32 x, f32 y, f32 z, f32 radius, GTA::Vehicle^ pVehicle) 
		 {
			Scripting::Vehicle tmppVehicle;
			pin_ptr<Scripting::Vehicle> pptmppVehicle = &tmppVehicle;
			Scripting::GetNearestCableCar(x, y, z, radius, pptmppVehicle);
			pVehicle->Base = tmppVehicle;
		 }
		static void GetNumCarColours (GTA::Vehicle^ vehicle, u32* pNumColours) { return Scripting::GetNumCarColours(vehicle->Base, pNumColours); }
		static void GetNumberOfPassengers (GTA::Vehicle^ vehicle, u32* pNumPassengers) { return Scripting::GetNumberOfPassengers(vehicle->Base, pNumPassengers); }
		static void GetOffsetFromCarGivenWorldCoords (GTA::Vehicle^ vehicle, f32 x, f32 y, f32 z, f32* pOffX, f32* pOffY, f32* pOffZ) { return Scripting::GetOffsetFromCarGivenWorldCoords(vehicle->Base, x, y, z, pOffX, pOffY, pOffZ); }
		static void GetOffsetFromCarInWorldCoords (GTA::Vehicle^ vehicle, f32 x, f32 y, f32 z, f32* pOffX, f32* pOffY, f32* pOffZ) { return Scripting::GetOffsetFromCarInWorldCoords(vehicle->Base, x, y, z, pOffX, pOffY, pOffZ); }
		static f32 GetPetrolTankHealth (GTA::Vehicle^ vehicle) { return Scripting::GetPetrolTankHealth(vehicle->Base); }
		static void GetRandomCarModelInMemory (b8 unknownTrue, u32* pHash, Scripting::ScriptAny* pUnknown) { return Scripting::GetRandomCarModelInMemory(unknownTrue, pHash, pUnknown); }
		static void GetVehicleDirtLevel (GTA::Vehicle^ vehicle, f32* pIntensity) { return Scripting::GetVehicleDirtLevel(vehicle->Base, pIntensity); }
		static b8 HasCarBeenDamagedByCar (GTA::Vehicle^ vehicle, GTA::Vehicle^ otherCar) { return Scripting::HasCarBeenDamagedByCar(vehicle->Base, otherCar->Base); }
		static b8 HasCarBeenDamagedByChar (GTA::Vehicle^ vehicle, GTA::Ped^ ped) { return Scripting::HasCarBeenDamagedByChar(vehicle->Base, ped->Base); }
		static b8 HasCarBeenDamagedByWeapon (GTA::Vehicle^ vehicle, GTA::eWeapon weapon) { return Scripting::HasCarBeenDamagedByWeapon(vehicle->Base, (Scripting::eWeapon)weapon); }
		static b8 HasCarBeenResprayed (GTA::Vehicle^ vehicle) { return Scripting::HasCarBeenResprayed(vehicle->Base); }
		static b8 IsBigVehicle (GTA::Vehicle^ vehicle) { return Scripting::IsBigVehicle(vehicle->Base); }
		static b8 IsCarAMissionCar (GTA::Vehicle^ vehicle) { return Scripting::IsCarAMissionCar(vehicle->Base); }
		static b8 IsCarAttached (GTA::Vehicle^ vehicle) { return Scripting::IsCarAttached(vehicle->Base); }
		static b8 IsCarDead (GTA::Vehicle^ vehicle) { return Scripting::IsCarDead(vehicle->Base); }
		static b8 IsCarDoorDamaged (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door) { return Scripting::IsCarDoorDamaged(vehicle->Base, (Scripting::eVehicleDoor)door); }
		static b8 IsCarDoorFullyOpen (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door) { return Scripting::IsCarDoorFullyOpen(vehicle->Base, (Scripting::eVehicleDoor)door); }
		static b8 IsCarInAirProper (GTA::Vehicle^ vehicle) { return Scripting::IsCarInAirProper(vehicle->Base); }
		static b8 IsCarInArea2D (GTA::Vehicle^ vehicle, f32 x1, f32 y1, f32 x2, f32 y2, b8 unknownFalse) { return Scripting::IsCarInArea2D(vehicle->Base, x1, y1, x2, y2, unknownFalse); }
		static b8 IsCarInArea3D (GTA::Vehicle^ vehicle, f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, u8 unknownFalse) { return Scripting::IsCarInArea3D(vehicle->Base, x1, y1, z1, x2, y2, z2, unknownFalse); }
		static b8 IsCarInWater (GTA::Vehicle^ vehicle) { return Scripting::IsCarInWater(vehicle->Base); }
		static b8 IsCarModel (GTA::Vehicle^ vehicle, GTA::eModel model) { return Scripting::IsCarModel(vehicle->Base, (Scripting::eModel)model); }
		static b8 IsCarOnFire (GTA::Vehicle^ vehicle) { return Scripting::IsCarOnFire(vehicle->Base); }
		static b8 IsCarOnScreen (GTA::Vehicle^ vehicle) { return Scripting::IsCarOnScreen(vehicle->Base); }
		static b8 IsCarPassengerSeatFree (GTA::Vehicle^ vehicle, u32 seatIndex) { return Scripting::IsCarPassengerSeatFree(vehicle->Base, seatIndex); }
		static b8 IsCarSirenOn (GTA::Vehicle^ vehicle) { return Scripting::IsCarSirenOn(vehicle->Base); }
		static b8 IsCarStopped (GTA::Vehicle^ vehicle) { return Scripting::IsCarStopped(vehicle->Base); }
		static b8 IsCarStoppedAtTrafficLights (GTA::Vehicle^ vehicle) { return Scripting::IsCarStoppedAtTrafficLights(vehicle->Base); }
		static b8 IsCarStuckOnRoof (GTA::Vehicle^ vehicle) { return Scripting::IsCarStuckOnRoof(vehicle->Base); }
		static b8 IsCarTouchingCar (GTA::Vehicle^ vehicle, GTA::Vehicle^ otherCar) { return Scripting::IsCarTouchingCar(vehicle->Base, otherCar->Base); }
		static b8 IsCarTyreBurst (GTA::Vehicle^ vehicle, GTA::eVehicleTyre tyre) { return Scripting::IsCarTyreBurst(vehicle->Base, (Scripting::eVehicleTyre)tyre); }
		static b8 IsCarUpright (GTA::Vehicle^ vehicle) { return Scripting::IsCarUpright(vehicle->Base); }
		static b8 IsCarUpsidedown (GTA::Vehicle^ vehicle) { return Scripting::IsCarUpsidedown(vehicle->Base); }
		static b8 IsCarWaitingForWorldCollision (GTA::Vehicle^ vehicle) { return Scripting::IsCarWaitingForWorldCollision(vehicle->Base); }
		static b8 IsVehDriveable (GTA::Vehicle^ vehicle) { return Scripting::IsVehDriveable(vehicle->Base); }
		static b8 IsVehWindowIntact (GTA::Vehicle^ vehicle, GTA::eVehicleWindow window) { return Scripting::IsVehWindowIntact(vehicle->Base, (Scripting::eVehicleWindow)window); }
		static b8 IsVehicleExtraTurnedOn (GTA::Vehicle^ vehicle, GTA::eVehicleExtra extra) { return Scripting::IsVehicleExtraTurnedOn(vehicle->Base, (Scripting::eVehicleExtra)extra); }
		static b8 IsVehicleOnAllWheels (GTA::Vehicle^ vehicle) { return Scripting::IsVehicleOnAllWheels(vehicle->Base); }
		static void KnockPedOffBike (GTA::Vehicle^ vehicle) { return Scripting::KnockPedOffBike(vehicle->Base); }
		static void LockCarDoors (GTA::Vehicle^ vehicle, GTA::eVehicleDoorLock value) { return Scripting::LockCarDoors(vehicle->Base, (Scripting::eVehicleDoorLock)value); }
		static void MarkCarAsConvoyCar (GTA::Vehicle^ vehicle, b8 convoyCar) { return Scripting::MarkCarAsConvoyCar(vehicle->Base, convoyCar); }
		static void MarkCarAsNoLongerNeeded (GTA::Vehicle^ pVehicle) 
		 {
			Scripting::Vehicle tmppVehicle;
			pin_ptr<Scripting::Vehicle> pptmppVehicle = &tmppVehicle;
			Scripting::MarkCarAsNoLongerNeeded(pptmppVehicle);
			pVehicle->Base = tmppVehicle;
		 }
		static void OpenCarDoor (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door) { return Scripting::OpenCarDoor(vehicle->Base, (Scripting::eVehicleDoor)door); }
		static void PopCarBoot (GTA::Vehicle^ vehicle) { return Scripting::PopCarBoot(vehicle->Base); }
		static void RemoveVehicleWindow (GTA::Vehicle^ vehicle, GTA::eVehicleWindow window) { return Scripting::RemoveVehicleWindow(vehicle->Base, (Scripting::eVehicleWindow)window); }
		static void RemoveStuckCarCheck (GTA::Vehicle^ vehicle) { return Scripting::RemoveStuckCarCheck(vehicle->Base); }
		static void RemoveUpsidedownCarCheck (GTA::Vehicle^ vehicle) { return Scripting::RemoveUpsidedownCarCheck(vehicle->Base); }
		static void SetCarCoordinates (GTA::Vehicle^ vehicle, f32 pX, f32 pY, f32 pZ) { return Scripting::SetCarCoordinates(vehicle->Base, pX, pY, pZ); }
		static void SetCarHealth (GTA::Vehicle^ vehicle, u32 pValue) { return Scripting::SetCarHealth(vehicle->Base, pValue); }
		static void SetPetrolTankHealth (GTA::Vehicle^ vehicle, f32 value) { return Scripting::SetPetrolTankHealth(vehicle->Base, value); }
		static void SetCarCanBeDamaged (GTA::Vehicle^ vehicle, b8 value) { return Scripting::SetCarCanBeDamaged(vehicle->Base, value); }
		static void SetCarCanBeVisiblyDamaged (GTA::Vehicle^ vehicle, b8 value) { return Scripting::SetCarCanBeVisiblyDamaged(vehicle->Base, value); }
		static void SetCarForwardSpeed (GTA::Vehicle^ vehicle, f32 speed) { return Scripting::SetCarForwardSpeed(vehicle->Base, speed); }
		static void SetCarHeading (GTA::Vehicle^ vehicle, f32 dir) { return Scripting::SetCarHeading(vehicle->Base, dir); }
		static Scripting::ScriptAny SetCarOnGroundProperly (GTA::Vehicle^ vehicle) { return Scripting::SetCarOnGroundProperly(vehicle->Base); }
		static void SetCarProofs (GTA::Vehicle^ vehicle, b8 bulletProof, b8 fireProof, b8 explosionProof, b8 collisionProof, b8 meleeProof) { return Scripting::SetCarProofs(vehicle->Base, bulletProof, fireProof, explosionProof, collisionProof, meleeProof); }
		static void SetCarStrong (GTA::Vehicle^ vehicle, b8 strong) { return Scripting::SetCarStrong(vehicle->Base, strong); }
		static void SetCarVisible (GTA::Vehicle^ vehicle, b8 value) { return Scripting::SetCarVisible(vehicle->Base, value); }
		static void SetExtraCarColours (GTA::Vehicle^ vehicle, Scripting::ColourIndex colour1, Scripting::ColourIndex colour2) { return Scripting::SetExtraCarColours(vehicle->Base, colour1, colour2); }
		static void SetEngineHealth (GTA::Vehicle^ vehicle, f32 health) { return Scripting::SetEngineHealth(vehicle->Base, health); }
		static void SetVehHazardLights (GTA::Vehicle^ vehicle, b8 on) { return Scripting::SetVehHazardLights(vehicle->Base, on); }
		static void SetVehicleDirtLevel (GTA::Vehicle^ vehicle, f32 intensity) { return Scripting::SetVehicleDirtLevel(vehicle->Base, intensity); }
		static void ShutCarDoor (GTA::Vehicle^ vehicle, GTA::eVehicleDoor door) { return Scripting::ShutCarDoor(vehicle->Base, (Scripting::eVehicleDoor)door); }
		static void SoundCarHorn (GTA::Vehicle^ vehicle, u32 duration) { return Scripting::SoundCarHorn(vehicle->Base, duration); }
		static void WashVehicleTextures (GTA::Vehicle^ vehicle, u32 intensity) { return Scripting::WashVehicleTextures(vehicle->Base, intensity); }

		// Train
		static void CreateMissionTrain (u32 unknown1, f32 x, f32 y, f32 z, b8 unknown2, Scripting::Train* pTrain) { return Scripting::CreateMissionTrain(unknown1, x, y, z, unknown2, pTrain); }
		static void DeleteMissionTrain (Scripting::Train* pTrain) { return Scripting::DeleteMissionTrain(pTrain); }
		static GTA::eTrainStation GetCurrentStationForTrain (Scripting::Train train) { return (GTA::eTrainStation) Scripting::GetCurrentStationForTrain(train); }
		static GTA::eTrainStation GetNextStationForTrain (Scripting::Train train) { return (GTA::eTrainStation) Scripting::GetNextStationForTrain(train); }
		//ConvertMe//    static constchr *GetStationName(Train train, eTrainStation station) { return NativeInvoke::Invoke<NATIVE_GET_STATION_NAME, constchr *>(train, station); }
		static void MarkMissionTrainAsNoLongerNeeded (Scripting::Train train) { return Scripting::MarkMissionTrainAsNoLongerNeeded(train); }
		static void MarkMissionTrainsAsNoLongerNeeded () { return Scripting::MarkMissionTrainsAsNoLongerNeeded(); }

		// Object
		static void AddObjectToInteriorRoomByKey (GTA::GameObject^ obj, GTA::eInteriorRoomKey roomKey) { return Scripting::AddObjectToInteriorRoomByKey(obj->Base, (Scripting::eInteriorRoomKey)roomKey); }
		static void ApplyForceToObject (GTA::GameObject^ obj, u32 uk0_3, f32 pX, f32 pY, f32 pZ, f32 spinX, f32 spinY, f32 spinZ, u32 uk4_0, u32 uk5_1, u32 uk6_1, u32 uk7_1) { return Scripting::ApplyForceToObject(obj->Base, uk0_3, pX, pY, pZ, spinX, spinY, spinZ, uk4_0, uk5_1, uk6_1, uk7_1); }
		static void AttachObjectToCar (GTA::GameObject^ obj, GTA::Vehicle^ v, u32 unknown0_0, f32 pX, f32 pY, f32 pZ, f32 rX, f32 rY, f32 rZ) { return Scripting::AttachObjectToCar(obj->Base, v->Base, unknown0_0, pX, pY, pZ, rX, rY, rZ); }
		static void AttachObjectToPed (GTA::GameObject^ obj, GTA::Ped^ c, GTA::ePedBone bone, f32 pX, f32 pY, f32 pZ, f32 rX, f32 rY, f32 rZ, u32 unknown1_0) { return Scripting::AttachObjectToPed(obj->Base, c->Base, (Scripting::ePedBone)bone, pX, pY, pZ, rX, rY, rZ, unknown1_0); }
		static void ClearObjectLastDamageEntity (GTA::GameObject^ obj) { return Scripting::ClearObjectLastDamageEntity(obj->Base); }
		static void ClearRoomForObject (GTA::GameObject^ obj) { return Scripting::ClearRoomForObject(obj->Base); }
		static void CreateObject (GTA::eModel model, f32 x, f32 y, f32 z, GTA::GameObject^ pObj, b8 unknownTrue) 
		 {
			Scripting::Object tmppObj;
			pin_ptr<Scripting::Object> pptmppObj = &tmppObj;
			Scripting::CreateObject((Scripting::eModel)model, x, y, z, pptmppObj, unknownTrue);
			pObj->Base = tmppObj;
		 }
		static void CreateObjectNoOffset (GTA::eModel model, f32 x, f32 y, f32 z, GTA::GameObject^ pObj, b8 unknownTrue) 
		 {
			Scripting::Object tmppObj;
			pin_ptr<Scripting::Object> pptmppObj = &tmppObj;
			Scripting::CreateObjectNoOffset((Scripting::eModel)model, x, y, z, pptmppObj, unknownTrue);
			pObj->Base = tmppObj;
		 }
		static void DeleteObject (GTA::GameObject^ pObj) 
		 {
			Scripting::Object tmppObj;
			pin_ptr<Scripting::Object> pptmppObj = &tmppObj;
			Scripting::DeleteObject(pptmppObj);
			pObj->Base = tmppObj;
		 }
		static void DetachObject (GTA::GameObject^ obj, b8 unknown) { return Scripting::DetachObject(obj->Base, unknown); }
		static b8 DoesObjectExist (GTA::GameObject^ obj) { return Scripting::DoesObjectExist(obj->Base); }
		static b8 DoesObjectHavePhysics (GTA::GameObject^ obj) { return Scripting::DoesObjectHavePhysics(obj->Base); }
		static b8 DoesObjectOfTypeExistAtCoords (f32 x, f32 y, f32 z, f32 radius, GTA::eModel model) { return Scripting::DoesObjectOfTypeExistAtCoords(x, y, z, radius, (Scripting::eModel)model); }
		static void ExtinguishObjectFire (GTA::GameObject^ obj) { return Scripting::ExtinguishObjectFire(obj->Base); }
		static void FreezeObjectPosition (GTA::GameObject^ obj, b8 frozen) { return Scripting::FreezeObjectPosition(obj->Base, frozen); }
		static GTA::Vehicle^ GetCarObjectIsAttachedTo (GTA::GameObject^ obj) { return gcnew GTA::Vehicle( Scripting::GetCarObjectIsAttachedTo(obj->Base)); }
		static void GetObjectCoordinates (GTA::GameObject^ obj, f32* pX, f32* pY, f32* pZ) { return Scripting::GetObjectCoordinates(obj->Base, pX, pY, pZ); }
		static f32 GetObjectFragmentDamageHealth (GTA::GameObject^ obj, b8 unknown) { return Scripting::GetObjectFragmentDamageHealth(obj->Base, unknown); }
		static void GetObjectHeading (GTA::GameObject^ obj, f32* pHeading) { return Scripting::GetObjectHeading(obj->Base, pHeading); }
		static void GetObjectHealth (GTA::GameObject^ obj, f32* pHealth) { return Scripting::GetObjectHealth(obj->Base, pHealth); }
		static void GetObjectModel (GTA::GameObject^ obj, GTA::eModel* pModel) { return Scripting::GetObjectModel(obj->Base, (Scripting::eModel*)pModel); }
		static void GetObjectRotationVelocity (GTA::GameObject^ obj, f32* pX, f32* pY, f32* pZ) { return Scripting::GetObjectRotationVelocity(obj->Base, pX, pY, pZ); }
		static void GetObjectSpeed (GTA::GameObject^ obj, f32* pSpeed) { return Scripting::GetObjectSpeed(obj->Base, pSpeed); }
		static void GetObjectVelocity (GTA::GameObject^ obj, f32* pX, f32* pY, f32* pZ) { return Scripting::GetObjectVelocity(obj->Base, pX, pY, pZ); }
		static void GetOffsetFromObjectInWorldCoords (GTA::GameObject^ obj, f32 x, f32 y, f32 z, f32* pOffX, f32* pOffY, f32* pOffZ) { return Scripting::GetOffsetFromObjectInWorldCoords(obj->Base, x, y, z, pOffX, pOffY, pOffZ); }
		static GTA::Ped^ GetPedObjectIsAttachedTo (GTA::GameObject^ obj) { return gcnew GTA::Ped( Scripting::GetPedObjectIsAttachedTo(obj->Base)); }
		static b8 HasObjectBeenDamaged (GTA::GameObject^ obj) { return Scripting::HasObjectBeenDamaged(obj->Base); }
		static b8 HasObjectBeenDamagedByCar (GTA::GameObject^ obj, GTA::Vehicle^ vehicle) { return Scripting::HasObjectBeenDamagedByCar(obj->Base, vehicle->Base); }
		static b8 HasObjectBeenDamagedByChar (GTA::GameObject^ obj, GTA::Ped^ ped) { return Scripting::HasObjectBeenDamagedByChar(obj->Base, ped->Base); }
		static b8 HasObjectBeenUprooted (GTA::GameObject^ obj) { return Scripting::HasObjectBeenUprooted(obj->Base); }
		static b8 HasObjectCollidedWithAnything (GTA::GameObject^ obj) { return Scripting::HasObjectCollidedWithAnything(obj->Base); }
		static b8 HasPoolObjectCollidedWithCushion (GTA::GameObject^ obj) { return Scripting::HasPoolObjectCollidedWithCushion(obj->Base); }
		static b8 HasPoolObjectCollidedWithObject (GTA::GameObject^ obj, GTA::GameObject^ otherObj) { return Scripting::HasPoolObjectCollidedWithObject(obj->Base, otherObj->Base); }
		static b8 IsObjectAttached (GTA::GameObject^ obj) { return Scripting::IsObjectAttached(obj->Base); }
		static b8 IsObjectInWater (GTA::GameObject^ obj) { return Scripting::IsObjectInWater(obj->Base); }
		static b8 IsObjectOnFire (GTA::GameObject^ obj) { return Scripting::IsObjectOnFire(obj->Base); }
		static b8 IsObjectOnScreen (GTA::GameObject^ obj) { return Scripting::IsObjectOnScreen(obj->Base); }
		static b8 IsObjectStatic (GTA::GameObject^ obj) { return Scripting::IsObjectStatic(obj->Base); }
		static b8 IsObjectUpright (GTA::GameObject^ obj, f32 angle) { return Scripting::IsObjectUpright(obj->Base, angle); }
		static b8 IsObjectWithinBrainActivationRange (GTA::GameObject^ obj) { return Scripting::IsObjectWithinBrainActivationRange(obj->Base); }
		static void LoadAllObjectsNow () { return Scripting::LoadAllObjectsNow(); }
		static void MakeObjectTargettable (GTA::GameObject^ obj, b8 targettable) { return Scripting::MakeObjectTargettable(obj->Base, targettable); }
		static void MarkObjectAsNoLongerNeeded (GTA::GameObject^ pObj) 
		 {
			Scripting::Object tmppObj;
			pin_ptr<Scripting::Object> pptmppObj = &tmppObj;
			Scripting::MarkObjectAsNoLongerNeeded(pptmppObj);
			pObj->Base = tmppObj;
		 }
		static void SetObjectCollision (GTA::GameObject^ obj, b8 value) { return Scripting::SetObjectCollision(obj->Base, value); }
		static void SetObjectCoordinates (GTA::GameObject^ obj, f32 pX, f32 pY, f32 pZ) { return Scripting::SetObjectCoordinates(obj->Base, pX, pY, pZ); }
		static void SetObjectHeading (GTA::GameObject^ obj, f32 value) { return Scripting::SetObjectHeading(obj->Base, value); }
		static void SetObjectVisible (GTA::GameObject^ obj, b8 value) { return Scripting::SetObjectVisible(obj->Base, value); }
		static Scripting::ScriptAny StartObjectFire (GTA::GameObject^ obj) { return Scripting::StartObjectFire(obj->Base); }

		// Models
		static b8 HasModelLoaded (GTA::eModel model) { return Scripting::HasModelLoaded((Scripting::eModel)model); }
		static void RequestModel (GTA::eModel model) { return Scripting::RequestModel((Scripting::eModel)model); }
		static void GetCurrentBasicCopModel (GTA::eModel* pModel) { return Scripting::GetCurrentBasicCopModel((Scripting::eModel*)pModel); }
		static void GetCurrentBasicPoliceCarModel (GTA::eModel* pModel) { return Scripting::GetCurrentBasicPoliceCarModel((Scripting::eModel*)pModel); }
		static void GetCurrentCopModel (GTA::eModel* pModel) { return Scripting::GetCurrentCopModel((Scripting::eModel*)pModel); }
		static void GetCurrentPoliceCarModel (GTA::eModel* pModel) { return Scripting::GetCurrentPoliceCarModel((Scripting::eModel*)pModel); }
		static void GetCurrentTaxiCarModel (GTA::eModel* pModel) { return Scripting::GetCurrentTaxiCarModel((Scripting::eModel*)pModel); }
		//ConvertMe//    static constchr *GetDisplayNameFromVehicleModel(eModel model) { return NativeInvoke::Invoke<NATIVE_GET_DISPLAY_NAME_FROM_VEHICLE_MODEL, constchr *>(model); }
		static void GetModelDimensions (GTA::eModel model, GTA::Vector3^ pMinVector, GTA::Vector3^ pMaxVector) 
		 {
			Scripting::Vector3 tmppMinVector;
			pin_ptr<Scripting::Vector3> pptmppMinVector = &tmppMinVector;
			Scripting::Vector3 tmppMaxVector;
			pin_ptr<Scripting::Vector3> pptmppMaxVector = &tmppMaxVector;
			Scripting::GetModelDimensions((Scripting::eModel)model, pptmppMinVector, pptmppMaxVector);
			pMinVector->Base = &tmppMinVector;
		 pMaxVector->Base = &tmppMaxVector;
		 }
		//ConvertMe//    static constchr *GetModelNameForDebug(eModel model) { return NativeInvoke::Invoke<NATIVE_GET_MODEL_NAME_FOR_DEBUG, constchr *>(model); }
		static b8 IsThisModelABike (GTA::eModel model) { return Scripting::IsThisModelABike((Scripting::eModel)model); }
		static b8 IsThisModelABoat (GTA::eModel model) { return Scripting::IsThisModelABoat((Scripting::eModel)model); }
		static b8 IsThisModelACar (GTA::eModel model) { return Scripting::IsThisModelACar((Scripting::eModel)model); }
		static b8 IsThisModelAHeli (GTA::eModel model) { return Scripting::IsThisModelAHeli((Scripting::eModel)model); }
		static b8 IsThisModelAPed (GTA::eModel model) { return Scripting::IsThisModelAPed((Scripting::eModel)model); }
		static b8 IsThisModelAPlane (GTA::eModel model) { return Scripting::IsThisModelAPlane((Scripting::eModel)model); }
		static b8 IsThisModelATrain (GTA::eModel model) { return Scripting::IsThisModelATrain((Scripting::eModel)model); }
		static b8 IsThisModelAVehicle (GTA::eModel model) { return Scripting::IsThisModelAVehicle((Scripting::eModel)model); }
		static void MarkModelAsNoLongerNeeded (GTA::eModel model) { return Scripting::MarkModelAsNoLongerNeeded((Scripting::eModel)model); }

		// Interiors
		static void ActivateInterior (GTA::Interior^ interior, b8 unknownTrue) { return Scripting::ActivateInterior(interior->Base, unknownTrue); }
		static void GetInteriorAtCoords (f32 x, f32 y, f32 z, GTA::Interior^ pInterior) 
		 {
			Scripting::Interior tmppInterior;
			pin_ptr<Scripting::Interior> pptmppInterior = &tmppInterior;
			Scripting::GetInteriorAtCoords(x, y, z, pptmppInterior);
			pInterior->Base = tmppInterior;
		 }
		static void GetInteriorFromCar (GTA::Vehicle^ vehicle, GTA::Interior^ pInterior) 
		 {
			Scripting::Interior tmppInterior;
			pin_ptr<Scripting::Interior> pptmppInterior = &tmppInterior;
			Scripting::GetInteriorFromCar(vehicle->Base, pptmppInterior);
			pInterior->Base = tmppInterior;
		 }
		static void GetInteriorFromChar (GTA::Ped^ ped, GTA::Interior^ pInterior) 
		 {
			Scripting::Interior tmppInterior;
			pin_ptr<Scripting::Interior> pptmppInterior = &tmppInterior;
			Scripting::GetInteriorFromChar(ped->Base, pptmppInterior);
			pInterior->Base = tmppInterior;
		 }
		static void GetInteriorHeading (GTA::Interior^ interior, f32* pHeading) { return Scripting::GetInteriorHeading(interior->Base, pHeading); }
		static void GetOffsetFromInteriorInWorldCoords (GTA::Interior^ interior, f32 x, f32 y, f32 z, f32* pOffset) { return Scripting::GetOffsetFromInteriorInWorldCoords(interior->Base, x, y, z, pOffset); }
		static void GetRoomKeyFromObject (GTA::GameObject^ obj, GTA::eInteriorRoomKey* pRoomKey) { return Scripting::GetRoomKeyFromObject(obj->Base, (Scripting::eInteriorRoomKey*)pRoomKey); }
		static void RequestInteriorModels (GTA::eModel model, String^ interiorName) 
		 {
			marshal_context^ coninteriorName = gcnew marshal_context();;
			const char* cinteriorName = coninteriorName->marshal_as<const char*>(interiorName);
			Scripting::RequestInteriorModels((Scripting::eModel)model, cinteriorName);
			delete coninteriorName;
		 }

		// Decision Maker
		static void AddCharDecisionMakerEventResponse (GTA::DecisionMaker^ dm, u32 eventid, u32 responseid, f32 param1, f32 param2, f32 param3, f32 param4, u32 unknown0_1, u32 unknown1_1) { return Scripting::AddCharDecisionMakerEventResponse(dm->Base, eventid, responseid, param1, param2, param3, param4, unknown0_1, unknown1_1); }
		static void AddCombatDecisionMakerEventResponse (GTA::DecisionMaker^ dm, u32 eventid, u32 responseid, f32 param1, f32 param2, f32 param3, f32 param4, u32 unknown0_1, u32 unknown1_1) { return Scripting::AddCombatDecisionMakerEventResponse(dm->Base, eventid, responseid, param1, param2, param3, param4, unknown0_1, unknown1_1); }
		static void AddGroupDecisionMakerEventResponse (GTA::DecisionMaker^ dm, u32 eventid, u32 responseid, f32 param1, f32 param2, f32 param3, f32 param4, u32 unknown0_1, u32 unknown1_1) { return Scripting::AddGroupDecisionMakerEventResponse(dm->Base, eventid, responseid, param1, param2, param3, param4, unknown0_1, unknown1_1); }
		static void ClearCharDecisionMakerEventResponse (GTA::DecisionMaker^ dm, u32 eventid) { return Scripting::ClearCharDecisionMakerEventResponse(dm->Base, eventid); }
		static void ClearCombatDecisionMakerEventResponse (GTA::DecisionMaker^ dm, u32 eventid) { return Scripting::ClearCombatDecisionMakerEventResponse(dm->Base, eventid); }
		static void ClearGroupDecisionMakerEventResponse (GTA::DecisionMaker^ dm, u32 eventid) { return Scripting::ClearGroupDecisionMakerEventResponse(dm->Base, eventid); }
		static void CopyCharDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::CopyCharDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static void CopyCombatDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::CopyCombatDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static void CopyGroupCharDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::CopyGroupCharDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static void CopyGroupCombatDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::CopyGroupCombatDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static void CopySharedCharDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::CopySharedCharDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static void CopySharedCombatDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::CopySharedCombatDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static b8 DoesDecisionMakerExist (GTA::DecisionMaker^ dm) { return Scripting::DoesDecisionMakerExist(dm->Base); }
		static void LoadCharDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::LoadCharDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		static void LoadCombatDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::LoadCombatDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		 /* nullsub in 104 
		static void LoadGroupDecisionMaker (u32 type, GTA::DecisionMaker^ pDM) 
		 {
			Scripting::DecisionMaker tmppDM;
			pin_ptr<Scripting::DecisionMaker> pptmppDM = &tmppDM;
			Scripting::LoadGroupDecisionMaker(type, pptmppDM);
			pDM->Base = tmppDM;
		 }
		 */
		static void RemoveDecisionMaker (GTA::DecisionMaker^ dm) { return Scripting::RemoveDecisionMaker(dm->Base); }
		static void SetCharDecisionMaker (GTA::Ped^ ped, GTA::DecisionMaker^ dm) { return Scripting::SetCharDecisionMaker(ped->Base, dm->Base); }
		static void SetCharDecisionMakerToDefault (GTA::Ped^ ped) { return Scripting::SetCharDecisionMakerToDefault(ped->Base); }
		static void SetCombatDecisionMaker (GTA::Ped^ ped, GTA::DecisionMaker^ dm) { return Scripting::SetCombatDecisionMaker(ped->Base, dm->Base); }
		static void SetDecisionMakerAttributeCanChangeTarget (GTA::DecisionMaker^ dm, b8 value) { return Scripting::SetDecisionMakerAttributeCanChangeTarget(dm->Base, value); }
		static void SetDecisionMakerAttributeCaution (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeCaution(dm->Base, value); }
		static void SetDecisionMakerAttributeFireRate (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeFireRate(dm->Base, value); }
		static void SetDecisionMakerAttributeLowHealth (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeLowHealth(dm->Base, value); }
		static void SetDecisionMakerAttributeMovementStyle (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeMovementStyle(dm->Base, value); }
		static void SetDecisionMakerAttributeNavigationStyle (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeNavigationStyle(dm->Base, value); }
		static void SetDecisionMakerAttributeRetreatingBehaviour (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeRetreatingBehaviour(dm->Base, value); }
		static void SetDecisionMakerAttributeSightRange (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeSightRange(dm->Base, value); }
		static void SetDecisionMakerAttributeStandingStyle (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeStandingStyle(dm->Base, value); }
		static void SetDecisionMakerAttributeTargetInjuredReaction (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeTargetInjuredReaction(dm->Base, value); }
		static void SetDecisionMakerAttributeTargetLossResponse (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeTargetLossResponse(dm->Base, value); }
		static void SetDecisionMakerAttributeTeamwork (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeTeamwork(dm->Base, value); }
		static void SetDecisionMakerAttributeWeaponAccuracy (GTA::DecisionMaker^ dm, u32 value) { return Scripting::SetDecisionMakerAttributeWeaponAccuracy(dm->Base, value); }
		static void SetGroupCharDecisionMaker (GTA::Group^ group, GTA::DecisionMaker^ dm) { return Scripting::SetGroupCharDecisionMaker(group->Base, dm->Base); }
		static void SetGroupCombatDecisionMaker (GTA::Group^ group, GTA::DecisionMaker^ dm) { return Scripting::SetGroupCombatDecisionMaker(group->Base, dm->Base); }
		 /* nullsub in 104 */ // static void SetGroupDecisionMaker (GTA::Group^ group, GTA::DecisionMaker^ dm) { return Scripting::SetGroupDecisionMaker(group->Base, dm->Base); }

		// Blips
		static void AddBlipForCar (GTA::Vehicle^ vehicle, GTA::Blip^ pBlip) 
		 {
			Scripting::Blip tmppBlip;
			pin_ptr<Scripting::Blip> pptmppBlip = &tmppBlip;
			Scripting::AddBlipForCar(vehicle->Base, pptmppBlip);
			pBlip->Base = tmppBlip;
		 }
		static void AddBlipForChar (GTA::Ped^ ped, GTA::Blip^ pBlip) 
		 {
			Scripting::Blip tmppBlip;
			pin_ptr<Scripting::Blip> pptmppBlip = &tmppBlip;
			Scripting::AddBlipForChar(ped->Base, pptmppBlip);
			pBlip->Base = tmppBlip;
		 }
		static void AddBlipForContact (f32 x, f32 y, f32 z, GTA::Blip^ pBlip) 
		 {
			Scripting::Blip tmppBlip;
			pin_ptr<Scripting::Blip> pptmppBlip = &tmppBlip;
			Scripting::AddBlipForContact(x, y, z, pptmppBlip);
			pBlip->Base = tmppBlip;
		 }
		static void AddBlipForCoord (f32 x, f32 y, f32 z, GTA::Blip^ pBlip) 
		 {
			Scripting::Blip tmppBlip;
			pin_ptr<Scripting::Blip> pptmppBlip = &tmppBlip;
			Scripting::AddBlipForCoord(x, y, z, pptmppBlip);
			pBlip->Base = tmppBlip;
		 }
		static void AddBlipForObject (GTA::GameObject^ obj, GTA::Blip^ pBlip) 
		 {
			Scripting::Blip tmppBlip;
			pin_ptr<Scripting::Blip> pptmppBlip = &tmppBlip;
			Scripting::AddBlipForObject(obj->Base, pptmppBlip);
			pBlip->Base = tmppBlip;
		 }
		static void AddBlipForPickup (GTA::Pickup^ pickup, GTA::Blip^ pBlip) 
		 {
			Scripting::Blip tmppBlip;
			pin_ptr<Scripting::Blip> pptmppBlip = &tmppBlip;
			Scripting::AddBlipForPickup(pickup->Base, pptmppBlip);
			pBlip->Base = tmppBlip;
		 }
		static void AddSimpleBlipForPickup (GTA::Pickup^ pickup) { return Scripting::AddSimpleBlipForPickup(pickup->Base); }
		static void ChangeBlipAlpha (GTA::Blip^ blip, Scripting::ScriptAny alpha) { return Scripting::ChangeBlipAlpha(blip->Base, alpha); }
		static void ChangeBlipColour (GTA::Blip^ blip, Scripting::ColourIndex colour) { return Scripting::ChangeBlipColour(blip->Base, colour); }
		static void ChangeBlipDisplay (GTA::Blip^ blip, GTA::eBlipDisplay display) { return Scripting::ChangeBlipDisplay(blip->Base, (Scripting::eBlipDisplay)display); }
		static void ChangeBlipNameFromAscii (GTA::Blip^ blip, String^ blipName) 
		 {
			marshal_context^ conblipName = gcnew marshal_context();;
			const char* cblipName = conblipName->marshal_as<const char*>(blipName);
			Scripting::ChangeBlipNameFromAscii(blip->Base, cblipName);
			delete conblipName;
		 }
		static void ChangeBlipNameFromTextFile (GTA::Blip^ blip, String^ gxtName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::ChangeBlipNameFromTextFile(blip->Base, cgxtName);
			delete congxtName;
		 }
		static void ChangeBlipPriority (GTA::Blip^ blip, GTA::eBlipPriority priority) { return Scripting::ChangeBlipPriority(blip->Base, (Scripting::eBlipPriority)priority); }
		static void ChangeBlipScale (GTA::Blip^ blip, f32 scale) { return Scripting::ChangeBlipScale(blip->Base, scale); }
		static void ChangeBlipSprite (GTA::Blip^ blip, GTA::eBlipSprite sprite) { return Scripting::ChangeBlipSprite(blip->Base, (Scripting::eBlipSprite)sprite); }
		static void DimBlip (GTA::Blip^ blip, b8 unknownTrue) { return Scripting::DimBlip(blip->Base, unknownTrue); }
		static b8 DoesBlipExist (GTA::Blip^ blip) { return Scripting::DoesBlipExist(blip->Base); }
		static void FlashBlip (GTA::Blip^ blip, b8 on) { return Scripting::FlashBlip(blip->Base, on); }
		static void FlashBlipAlt (GTA::Blip^ blip, b8 on) { return Scripting::FlashBlipAlt(blip->Base, on); }
		static void GetBlipColour (GTA::Blip^ blip, Scripting::ColourIndex* pColour) { return Scripting::GetBlipColour(blip->Base, pColour); }
		static void GetBlipCoords (GTA::Blip^ blip, GTA::Vector3^ pVector) 
		 {
			Scripting::Vector3 tmppVector;
			pin_ptr<Scripting::Vector3> pptmppVector = &tmppVector;
			Scripting::GetBlipCoords(blip->Base, pptmppVector);
			pVector->Base = &tmppVector;
		 }
		static GTA::eBlipType^ GetBlipInfoIdType (GTA::Blip^ blip) { return (GTA::eBlipType)(Scripting::GetBlipInfoIdType(blip->Base)); }
		static GTA::Vehicle^ GetBlipInfoIdCarIndex (GTA::Blip^ blip) { return gcnew GTA::Vehicle( Scripting::GetBlipInfoIdCarIndex(blip->Base)); }
		static u32 GetBlipInfoIdDisplay (GTA::Blip^ blip) { return Scripting::GetBlipInfoIdDisplay(blip->Base); }
		static GTA::GameObject^ GetBlipInfoIdObjectIndex (GTA::Blip^ blip) { return gcnew GTA::GameObject( Scripting::GetBlipInfoIdObjectIndex(blip->Base)); }
		static GTA::Ped^ GetBlipInfoIdPedIndex (GTA::Blip^ blip) { return gcnew GTA::Ped( Scripting::GetBlipInfoIdPedIndex(blip->Base)); }
		static GTA::Pickup^ GetBlipInfoIdPickupIndex (GTA::Blip^ blip) { return gcnew GTA::Pickup( Scripting::GetBlipInfoIdPickupIndex(blip->Base)); }
		//ConvertMe//    /* No longer in 104 */ // static constchr *GetBlipName(Blip blip) { return NativeInvoke::Invoke<NATIVE_GET_BLIP_NAME, constchr *>(blip); }
		static GTA::eBlipSprite GetBlipSprite (GTA::Blip^ blip) { return (GTA::eBlipSprite) Scripting::GetBlipSprite(blip->Base); }
		static GTA::Blip^ GetFirstBlipInfoId (GTA::eBlipSprite type) { return gcnew GTA::Blip( Scripting::GetFirstBlipInfoId((Scripting::eBlipSprite)type)); }
		static GTA::Blip^ GetNextBlipInfoId (GTA::eBlipSprite type) { return gcnew GTA::Blip( Scripting::GetNextBlipInfoId((Scripting::eBlipSprite)type)); }
		static b8 IsBlipShortRange (GTA::Blip^ blip) { return Scripting::IsBlipShortRange(blip->Base); }
		static void RemoveBlip (GTA::Blip^ blip) { return Scripting::RemoveBlip(blip->Base); }
		static void SetBlipAsFriendly (GTA::Blip^ blip, b8 value) { return Scripting::SetBlipAsFriendly(blip->Base, value); }
		static void SetBlipAsShortRange (GTA::Blip^ blip, b8 value) { return Scripting::SetBlipAsShortRange(blip->Base, value); }
		static void SetRoute (GTA::Blip^ blip, b8 value) { return Scripting::SetRoute(blip->Base, value); }

		// Pickups
		static void AddPickupToInteriorRoomByName (GTA::Pickup^ pickup, String^ roomName) 
		 {
			marshal_context^ conroomName = gcnew marshal_context();;
			const char* croomName = conroomName->marshal_as<const char*>(roomName);
			Scripting::AddPickupToInteriorRoomByName(pickup->Base, croomName);
			delete conroomName;
		 }
		static void CreateMoneyPickup (f32 x, f32 y, f32 z, u32 amount, b8 unknownTrue, GTA::Pickup^ pPickup) 
		 {
			Scripting::Pickup tmppPickup;
			pin_ptr<Scripting::Pickup> pptmppPickup = &tmppPickup;
			Scripting::CreateMoneyPickup(x, y, z, amount, unknownTrue, pptmppPickup);
			pPickup->Base = tmppPickup;
		 }
		static void CreatePickup (GTA::eModel model, GTA::ePickupType pickupType, f32 x, f32 y, f32 z, GTA::Pickup^ pPickup, b8 unknownFalse) 
		 {
			Scripting::Pickup tmppPickup;
			pin_ptr<Scripting::Pickup> pptmppPickup = &tmppPickup;
			Scripting::CreatePickup((Scripting::eModel)model, (Scripting::ePickupType)pickupType, x, y, z, pptmppPickup, unknownFalse);
			pPickup->Base = tmppPickup;
		 }
		static void CreatePickupRotate (GTA::eModel model, GTA::ePickupType pickupType, u32 unknown, f32 x, f32 y, f32 z, f32 rX, f32 rY, f32 rZ, GTA::Pickup^ pPickup) 
		 {
			Scripting::Pickup tmppPickup;
			pin_ptr<Scripting::Pickup> pptmppPickup = &tmppPickup;
			Scripting::CreatePickupRotate((Scripting::eModel)model, (Scripting::ePickupType)pickupType, unknown, x, y, z, rX, rY, rZ, pptmppPickup);
			pPickup->Base = tmppPickup;
		 }
		static void CreatePickupWithAmmo (GTA::eModel model, GTA::ePickupType pickupType, u32 unknown, f32 x, f32 y, f32 z, GTA::Pickup^ pPickup) 
		 {
			Scripting::Pickup tmppPickup;
			pin_ptr<Scripting::Pickup> pptmppPickup = &tmppPickup;
			Scripting::CreatePickupWithAmmo((Scripting::eModel)model, (Scripting::ePickupType)pickupType, unknown, x, y, z, pptmppPickup);
			pPickup->Base = tmppPickup;
		 }
		static b8 DoesPickupExist (GTA::Pickup^ pickup) { return Scripting::DoesPickupExist(pickup->Base); }
		static void GetPickupCoordinates (GTA::Pickup^ pickup, f32* pX, f32* pY, f32* pZ) { return Scripting::GetPickupCoordinates(pickup->Base, pX, pY, pZ); }
		static b8 HasPickupBeenCollected (GTA::Pickup^ pickup) { return Scripting::HasPickupBeenCollected(pickup->Base); }
		static void PickupsPassTime (u32 time) { return Scripting::PickupsPassTime(time); }
		static void RemovePickup (GTA::Pickup^ pickup) { return Scripting::RemovePickup(pickup->Base); }
		static void RemoveTemporaryRadarBlipsForPickups () { return Scripting::RemoveTemporaryRadarBlipsForPickups(); }
		static void RenderWeaponPickupsBigger (b8 value) { return Scripting::RenderWeaponPickupsBigger(value); }

		// Camera
		static b8 CamIsSphereVisible (GTA::Camera^ camera, f32 pX, f32 pY, f32 pZ, f32 radius) { return Scripting::CamIsSphereVisible(camera->Base, pX, pY, pZ, radius); }
		static void CreateCam (u32 camtype_usually14, GTA::Camera^ camera) 
		 {
			Scripting::Camera tmpcamera;
			pin_ptr<Scripting::Camera> pptmpcamera = &tmpcamera;
			Scripting::CreateCam(camtype_usually14, pptmpcamera);
			camera->Base = tmpcamera;
		 }
		static void DestroyCam (GTA::Camera^ camera) { return Scripting::DestroyCam(camera->Base); }
		static b8 DoesCamExist (GTA::Camera^ camera) { return Scripting::DoesCamExist(camera->Base); }
		static void SetCamActive (GTA::Camera^ camera, bool value) { return Scripting::SetCamActive(camera->Base, value); }
		static void GetCamFov (GTA::Camera^ camera, f32* fov) { return Scripting::GetCamFov(camera->Base, fov); }
		static void GetCamPos (GTA::Camera^ camera, f32* pX, f32* pY, f32* pZ) { return Scripting::GetCamPos(camera->Base, pX, pY, pZ); }
		static void GetCamRot (GTA::Camera^ camera, f32* angleX, f32* angleY, f32* angleZ) { return Scripting::GetCamRot(camera->Base, angleX, angleY, angleZ); }
		static void GetGameCam (GTA::Camera^ camera) 
		 {
			Scripting::Camera tmpcamera;
			pin_ptr<Scripting::Camera> pptmpcamera = &tmpcamera;
			Scripting::GetGameCam(pptmpcamera);
			camera->Base = tmpcamera;
		 }
		static void GetGameCamChild (GTA::Camera^ camera) 
		 {
			Scripting::Camera tmpcamera;
			pin_ptr<Scripting::Camera> pptmpcamera = &tmpcamera;
			Scripting::GetGameCamChild(pptmpcamera);
			camera->Base = tmpcamera;
		 }
		static bool IsCamActive (GTA::Camera^ camera) { return Scripting::IsCamActive(camera->Base); }
		static bool IsCamInterpolating () { return Scripting::IsCamInterpolating(); }
		static bool IsCamPropagating (GTA::Camera^ camera) { return Scripting::IsCamPropagating(camera->Base); }
		static void SetCamBehindPed (GTA::Ped^ ped) { return Scripting::SetCamBehindPed(ped->Base); }
		static void SetCamFov (GTA::Camera^ camera, f32 fov) { return Scripting::SetCamFov(camera->Base, fov); }
		static void SetCamInFrontOfPed (GTA::Ped^ ped) { return Scripting::SetCamInFrontOfPed(ped->Base); }
		static void SetCamPos (GTA::Camera^ camera, f32 pX, f32 pY, f32 pZ) { return Scripting::SetCamPos(camera->Base, pX, pY, pZ); }
		static void SetCamPropagate (GTA::Camera^ camera, bool value) { return Scripting::SetCamPropagate(camera->Base, value); }
		static void SetCamRot (GTA::Camera^ camera, f32 angleX, f32 angleY, f32 angleZ) { return Scripting::SetCamRot(camera->Base, angleX, angleY, angleZ); }
		static void SetCamTargetPed (GTA::Camera^ camera, GTA::Ped^ ped) { return Scripting::SetCamTargetPed(camera->Base, ped->Base); }

		// Network
		static b8 NetworkIsGameRanked () { return Scripting::NetworkIsGameRanked(); }
		static b8 NetworkIsSessionStarted () { return Scripting::NetworkIsSessionStarted(); }

		// World
		static b8 AreAllNavmeshRegionsLoaded () { return Scripting::AreAllNavmeshRegionsLoaded(); }
		static void ClearArea (f32 x, f32 y, f32 z, f32 radius, b8 unknown) { return Scripting::ClearArea(x, y, z, radius, unknown); }
		static void ClearAreaOfCars (f32 x, f32 y, f32 z, f32 radius) { return Scripting::ClearAreaOfCars(x, y, z, radius); }
		static void ClearAreaOfChars (f32 x, f32 y, f32 z, f32 radius) { return Scripting::ClearAreaOfChars(x, y, z, radius); }
		static void ClearAreaOfCops (f32 x, f32 y, f32 z, f32 radius) { return Scripting::ClearAreaOfCops(x, y, z, radius); }
		static void ClearAreaOfObjects (f32 x, f32 y, f32 z, f32 radius) { return Scripting::ClearAreaOfObjects(x, y, z, radius); }
		static void ClearPedNonCreationArea () { return Scripting::ClearPedNonCreationArea(); }
		static void ClearPedNonRemovalArea () { return Scripting::ClearPedNonRemovalArea(); }
		static void ExtinguishFireAtPoint (f32 x, f32 y, f32 z, f32 radius) { return Scripting::ExtinguishFireAtPoint(x, y, z, radius); }
		static void ForceWeather (GTA::eWeather weather) { return Scripting::ForceWeather((Scripting::eWeather)weather); }
		static void ForceWeatherNow (GTA::eWeather weather) { return Scripting::ForceWeatherNow((Scripting::eWeather)weather); }
		static void ForceWind (f32 wind) { return Scripting::ForceWind(wind); }
		static void FreezePositionOfClosestObjectOfType (f32 x, f32 y, f32 z, f32 radius, GTA::eModel model, b8 frozen) { return Scripting::FreezePositionOfClosestObjectOfType(x, y, z, radius, (Scripting::eModel)model, frozen); }
		static GTA::Vehicle^ GetClosestCar (f32 x, f32 y, f32 z, f32 radius, b8 unknownFalse, u32 unknown70) { return gcnew GTA::Vehicle( Scripting::GetClosestCar(x, y, z, radius, unknownFalse, unknown70)); }
		static b8 GetClosestChar (f32 x, f32 y, f32 z, f32 radius, b8 unknown1, b8 unknown2, GTA::Ped^ pPed) 
		 {
			Scripting::Ped tmppPed;
			pin_ptr<Scripting::Ped> pptmppPed = &tmppPed;
			b8 retval = Scripting::GetClosestChar(x, y, z, radius, unknown1, unknown2, pptmppPed);
			pPed->Base = tmppPed;
		 return retval;
		 }
		static void GetCurrentWeather (GTA::eWeather* pWeather) { return Scripting::GetCurrentWeather((Scripting::eWeather*)pWeather); }
		static Scripting::ScriptAny GetGroundZFor3DCoord (f32 x, f32 y, f32 z, f32* pGroundZ) { return Scripting::GetGroundZFor3DCoord(x, y, z, pGroundZ); }
		static u32 GetNumberOfFiresInRange (f32 x, f32 y, f32 z, f32 radius) { return Scripting::GetNumberOfFiresInRange(x, y, z, radius); }
		static void GetSafePickupCoords (f32 x, f32 y, f32 z, f32* pSafeX, f32* pSafeY, f32* pSafeZ) { return Scripting::GetSafePickupCoords(x, y, z, pSafeX, pSafeY, pSafeZ); }
		static b8 GetSafePositionForChar (f32 x, f32 y, f32 z, b8 unknownTrue, f32* pSafeX, f32* pSafeY, f32* pSafeZ) { return Scripting::GetSafePositionForChar(x, y, z, unknownTrue, pSafeX, pSafeY, pSafeZ); }
		static b8 HasClosestObjectOfTypeBeenDamagedByChar (f32 x, f32 y, f32 z, f32 radius, GTA::eModel objectModel, GTA::Ped^ ped) { return Scripting::HasClosestObjectOfTypeBeenDamagedByChar(x, y, z, radius, (Scripting::eModel)objectModel, ped->Base); }
		static b8 IsAreaOccupied (f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, b8 unknownFalse1, b8 unknownTrue, b8 unknownFalse2, b8 unknownFalse3, b8 unknownFalse4) { return Scripting::IsAreaOccupied(x1, y1, z1, x2, y2, z2, unknownFalse1, unknownTrue, unknownFalse2, unknownFalse3, unknownFalse4); }
		static b8 IsBulletInArea (f32 x, f32 y, f32 z, f32 radius, b8 unknownTrue) { return Scripting::IsBulletInArea(x, y, z, radius, unknownTrue); }
		static b8 IsBulletInBox (f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, b8 unknown) { return Scripting::IsBulletInBox(x1, y1, z1, x2, y2, z2, unknown); }
		static b8 IsPointObscuredByAMissionEntity (f32 pX, f32 pY, f32 pZ, f32 sizeX, f32 sizeY, f32 sizeZ) { return Scripting::IsPointObscuredByAMissionEntity(pX, pY, pZ, sizeX, sizeY, sizeZ); }
		static void LoadScene (f32 x, f32 y, f32 z) { return Scripting::LoadScene(x, y, z); }
		static void RemoveAllPickupsOfType (GTA::ePickupType type) { return Scripting::RemoveAllPickupsOfType((Scripting::ePickupType)type); }
		static void RequestCollisionAtPosn (f32 x, f32 y, f32 z) { return Scripting::RequestCollisionAtPosn(x, y, z); }
		static void SwitchAmbientPlanes (b8 on) { return Scripting::SwitchAmbientPlanes(on); }
		static void SwitchArrowAboveBlippedPickups (b8 on) { return Scripting::SwitchArrowAboveBlippedPickups(on); }
		static void SwitchRandomBoats (b8 on) { return Scripting::SwitchRandomBoats(on); }
		static void SwitchRandomTrains (b8 on) { return Scripting::SwitchRandomTrains(on); }
		static void SwitchGarbageTrucks (b8 on) { return Scripting::SwitchGarbageTrucks(on); }
		static void SwitchMadDrivers (b8 on) { return Scripting::SwitchMadDrivers(on); }

		// Garages
		static void CloseGarage (String^ garageName) 
		 {
			marshal_context^ congarageName = gcnew marshal_context();;
			const char* cgarageName = congarageName->marshal_as<const char*>(garageName);
			Scripting::CloseGarage(cgarageName);
			delete congarageName;
		 }
		static b8 IsCarInGarageArea (String^ garageName, GTA::Vehicle^ vehicle) 
		 {
			marshal_context^ congarageName = gcnew marshal_context();;
			const char* cgarageName = congarageName->marshal_as<const char*>(garageName);
			b8 retval = Scripting::IsCarInGarageArea(cgarageName, vehicle->Base);
			delete congarageName;
		 return retval;
		 }
		static Scripting::ScriptAny IsGarageClosed (String^ garageName) 
		 {
			marshal_context^ congarageName = gcnew marshal_context();;
			const char* cgarageName = congarageName->marshal_as<const char*>(garageName);
			ScriptAny retval = Scripting::IsGarageClosed(cgarageName);
			delete congarageName;
		 return retval;
		 }
		static Scripting::ScriptAny IsGarageOpen (String^ garageName) 
		 {
			marshal_context^ congarageName = gcnew marshal_context();;
			const char* cgarageName = congarageName->marshal_as<const char*>(garageName);
			ScriptAny retval = Scripting::IsGarageOpen(cgarageName);
			delete congarageName;
		 return retval;
		 }
		static void OpenGarage (String^ name) 
		 {
			marshal_context^ conname = gcnew marshal_context();;
			const char* cname = conname->marshal_as<const char*>(name);
			Scripting::OpenGarage(cname);
			delete conname;
		 }

		// Text (GXT stuff)
		static void DisplayText (f32 x, f32 y, String^ gxtName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::DisplayText(x, y, cgxtName);
			delete congxtName;
		 }
		static void DisplayTextWith2Numbers (f32 x, f32 y, String^ gxtName, i32 number1, i32 number2) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::DisplayTextWith2Numbers(x, y, cgxtName, number1, number2);
			delete congxtName;
		 }
		static void DisplayTextWithFloat (f32 x, f32 y, String^ gxtName, f32 value, u32 unknown) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::DisplayTextWithFloat(x, y, cgxtName, value, unknown);
			delete congxtName;
		 }
		static void DisplayTextWithLiteralString (f32 x, f32 y, String^ gxtName, String^ literalStr) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ conliteralStr = gcnew marshal_context();;
			const char* cliteralStr = conliteralStr->marshal_as<const char*>(literalStr);
			Scripting::DisplayTextWithLiteralString(x, y, cgxtName, cliteralStr);
			delete congxtName;
		 delete conliteralStr;
		 }
		static void DisplayTextWithNumber (f32 x, f32 y, String^ gxtName, i32 value) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::DisplayTextWithNumber(x, y, cgxtName, value);
			delete congxtName;
		 }
		static void DisplayTextWithString (f32 x, f32 y, String^ gxtName, String^ gxtStringName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtStringName = gcnew marshal_context();;
			const char* cgxtStringName = congxtStringName->marshal_as<const char*>(gxtStringName);
			Scripting::DisplayTextWithString(x, y, cgxtName, cgxtStringName);
			delete congxtName;
		 delete congxtStringName;
		 }
		static void DisplayTextWithTwoLiteralStrings (f32 x, f32 y, String^ gxtName, String^ literalStr1, String^ literalStr2) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ conliteralStr1 = gcnew marshal_context();;
			const char* cliteralStr1 = conliteralStr1->marshal_as<const char*>(literalStr1);
			marshal_context^ conliteralStr2 = gcnew marshal_context();;
			const char* cliteralStr2 = conliteralStr2->marshal_as<const char*>(literalStr2);
			Scripting::DisplayTextWithTwoLiteralStrings(x, y, cgxtName, cliteralStr1, cliteralStr2);
			delete congxtName;
		 delete conliteralStr1;
		 delete conliteralStr2;
		 }
		static void DisplayTextWithTwoStrings (f32 x, f32 y, String^ gxtName, String^ gxtStringName1, String^ gxtStringName2) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtStringName1 = gcnew marshal_context();;
			const char* cgxtStringName1 = congxtStringName1->marshal_as<const char*>(gxtStringName1);
			marshal_context^ congxtStringName2 = gcnew marshal_context();;
			const char* cgxtStringName2 = congxtStringName2->marshal_as<const char*>(gxtStringName2);
			Scripting::DisplayTextWithTwoStrings(x, y, cgxtName, cgxtStringName1, cgxtStringName2);
			delete congxtName;
		 delete congxtStringName1;
		 delete congxtStringName2;
		 }
		static u32 GetLengthOfStringWithThisTextLabel (String^ gxtName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			u32 retval = Scripting::GetLengthOfStringWithThisTextLabel(cgxtName);
			delete congxtName;
		 return retval;
		 }
		//ConvertMe//    static constchr *GetFirstNCharactersOfString(constchr *gxtName, u32 chars) { return NativeInvoke::Invoke<NATIVE_GET_FIRST_N_CHARACTERS_OF_STRING, constchr *>(gxtName, chars); }
		static void GetMobilePhoneRenderId (u32* pRenderId) { return Scripting::GetMobilePhoneRenderId(pRenderId); }
		//ConvertMe//    static constchr *GetNthIntegerInString(constchr *gxtName, u32 index) { return NativeInvoke::Invoke<NATIVE_GET_NTH_INTEGER_IN_STRING, constchr *>(gxtName, index); }
		static void GetScriptRenderTargetRenderId (u32* pRenderId) { return Scripting::GetScriptRenderTargetRenderId(pRenderId); }
		//ConvertMe//    static constchr *GetStringFromHashKey(u32 hashKey) { return NativeInvoke::Invoke<NATIVE_GET_STRING_FROM_HASH_KEY, constchr *>(hashKey); }
		static Scripting::ScriptAny GetStringWidth (String^ gxtName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			ScriptAny retval = Scripting::GetStringWidth(cgxtName);
			delete congxtName;
		 return retval;
		 }
		static Scripting::ScriptAny GetStringWidthWithNumber (String^ gxtName, i32 number) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			ScriptAny retval = Scripting::GetStringWidthWithNumber(cgxtName, number);
			delete congxtName;
		 return retval;
		 }
		static Scripting::ScriptAny GetStringWidthWithString (String^ gxtName, String^ literalString) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ conliteralString = gcnew marshal_context();;
			const char* cliteralString = conliteralString->marshal_as<const char*>(literalString);
			ScriptAny retval = Scripting::GetStringWidthWithString(cgxtName, cliteralString);
			delete congxtName;
		 delete conliteralString;
		 return retval;
		 }
		static b8 HasAdditionalTextLoaded (u32 textIndex) { return Scripting::HasAdditionalTextLoaded(textIndex); }
		static b8 HasThisAdditionalTextLoaded (String^ textName, u32 textIndex) 
		 {
			marshal_context^ contextName = gcnew marshal_context();;
			const char* ctextName = contextName->marshal_as<const char*>(textName);
			b8 retval = Scripting::HasThisAdditionalTextLoaded(ctextName, textIndex);
			delete contextName;
		 return retval;
		 }
		static b8 IsFontLoaded (GTA::eTextFont font) { return Scripting::IsFontLoaded((Scripting::eTextFont)font); }
		static b8 IsStreamingAdditionalText (u32 textIndex) { return Scripting::IsStreamingAdditionalText(textIndex); }
		static void LoadAdditionalText (String^ textName, u32 textIndex) 
		 {
			marshal_context^ contextName = gcnew marshal_context();;
			const char* ctextName = contextName->marshal_as<const char*>(textName);
			Scripting::LoadAdditionalText(ctextName, textIndex);
			delete contextName;
		 }
		static void LoadTextFont (GTA::eTextFont font) { return Scripting::LoadTextFont((Scripting::eTextFont)font); }
		static void Print (String^ gxtName, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::Print(cgxtName, timeMS, enable);
			delete congxtName;
		 }
		static void PrintBig (String^ gxtName, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintBig(cgxtName, timeMS, enable);
			delete congxtName;
		 }
		static void PrintHelp (String^ gxtName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintHelp(cgxtName);
			delete congxtName;
		 }
		static void PrintHelpForever (String^ gxtName) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintHelpForever(cgxtName);
			delete congxtName;
		 }
		static void PrintHelpForeverWithNumber (String^ gxtName, i32 value) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintHelpForeverWithNumber(cgxtName, value);
			delete congxtName;
		 }
		static void PrintHelpForeverWithString (String^ gxtName, String^ gxtText) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtText = gcnew marshal_context();;
			const char* cgxtText = congxtText->marshal_as<const char*>(gxtText);
			Scripting::PrintHelpForeverWithString(cgxtName, cgxtText);
			delete congxtName;
		 delete congxtText;
		 }
		static void PrintHelpForeverWithStringNoSound (String^ gxtName, String^ gxtText) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtText = gcnew marshal_context();;
			const char* cgxtText = congxtText->marshal_as<const char*>(gxtText);
			Scripting::PrintHelpForeverWithStringNoSound(cgxtName, cgxtText);
			delete congxtName;
		 delete congxtText;
		 }
		static void PrintHelpWithNumber (String^ gxtName, i32 value) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintHelpWithNumber(cgxtName, value);
			delete congxtName;
		 }
		static void PrintHelpWithString (String^ gxtName, String^ gxtText) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtText = gcnew marshal_context();;
			const char* cgxtText = congxtText->marshal_as<const char*>(gxtText);
			Scripting::PrintHelpWithString(cgxtName, cgxtText);
			delete congxtName;
		 delete congxtText;
		 }
		static void PrintHelpWithStringNoSound (String^ gxtName, String^ gxtText) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtText = gcnew marshal_context();;
			const char* cgxtText = congxtText->marshal_as<const char*>(gxtText);
			Scripting::PrintHelpWithStringNoSound(cgxtName, cgxtText);
			delete congxtName;
		 delete congxtText;
		 }
		static void PrintNow (String^ gxtName, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintNow(cgxtName, timeMS, enable);
			delete congxtName;
		 }
		static void PrintStringInString (String^ gxtName, String^ gxtText, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtText = gcnew marshal_context();;
			const char* cgxtText = congxtText->marshal_as<const char*>(gxtText);
			Scripting::PrintStringInString(cgxtName, cgxtText, timeMS, enable);
			delete congxtName;
		 delete congxtText;
		 }
		static void PrintStringInStringNow (String^ gxtName, String^ gxtText, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ congxtText = gcnew marshal_context();;
			const char* cgxtText = congxtText->marshal_as<const char*>(gxtText);
			Scripting::PrintStringInStringNow(cgxtName, cgxtText, timeMS, enable);
			delete congxtName;
		 delete congxtText;
		 }
		static void PrintStringWithLiteralStringNow (String^ gxtName, String^ text, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			marshal_context^ context = gcnew marshal_context();;
			const char* ctext = context->marshal_as<const char*>(text);
			Scripting::PrintStringWithLiteralStringNow(cgxtName, ctext, timeMS, enable);
			delete congxtName;
		 delete context;
		 }
		static void PrintWith2Numbers (String^ gxtName, i32 value1, i32 value2, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintWith2Numbers(cgxtName, value1, value2, timeMS, enable);
			delete congxtName;
		 }
		static void PrintWith2NumbersNow (String^ gxtName, i32 value1, i32 value2, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintWith2NumbersNow(cgxtName, value1, value2, timeMS, enable);
			delete congxtName;
		 }
		static void PrintWithNumber (String^ gxtName, i32 value, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintWithNumber(cgxtName, value, timeMS, enable);
			delete congxtName;
		 }
		static void PrintWithNumberBig (String^ gxtName, i32 value, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintWithNumberBig(cgxtName, value, timeMS, enable);
			delete congxtName;
		 }
		static void PrintWithNumberNow (String^ gxtName, i32 value, u32 timeMS, b8 enable) 
		 {
			marshal_context^ congxtName = gcnew marshal_context();;
			const char* cgxtName = congxtName->marshal_as<const char*>(gxtName);
			Scripting::PrintWithNumberNow(cgxtName, value, timeMS, enable);
			delete congxtName;
		 }
		static void PrintFloat (f32 value) { return Scripting::PrintFloat(value); }
		static void PrintInt (i32 value) { return Scripting::PrintInt(value); }
		static void PrintNL () { return Scripting::PrintNL(); }
		static void PrintString (String^ value) 
		 {
			marshal_context^ convalue = gcnew marshal_context();;
			const char* cvalue = convalue->marshal_as<const char*>(value);
			Scripting::PrintString(cvalue);
			delete convalue;
		 }
		static void PrintVector (f32 x, f32 y, f32 z) { return Scripting::PrintVector(x, y, z); }
		static void RequestAdditionalText (String^ textName, u32 textIndex) 
		 {
			marshal_context^ contextName = gcnew marshal_context();;
			const char* ctextName = contextName->marshal_as<const char*>(textName);
			Scripting::RequestAdditionalText(ctextName, textIndex);
			delete contextName;
		 }
		static void SetTextScale (f32 w, f32 h) { return Scripting::SetTextScale(w, h); }
		static void SetTextBackground (b8 value) { return Scripting::SetTextBackground(value); }
		static void SetTextCentre (b8 value) { return Scripting::SetTextCentre(value); }
		static void SetTextColour (u8 r, u8 g, u8 b, u8 a) { return Scripting::SetTextColour(r, g, b, a); }
		static void SetTextDrawBeforeFade (b8 value) { return Scripting::SetTextDrawBeforeFade(value); }
		static void SetTextDropshadow (b8 displayShadow, u8 r, u8 g, u8 b, u8 a) { return Scripting::SetTextDropshadow(displayShadow, r, g, b, a); }
		static void SetTextEdge (b8 displayEdge, u8 r, u8 g, u8 b, u8 a) { return Scripting::SetTextEdge(displayEdge, r, g, b, a); }
		static void SetTextFont (GTA::eTextFont font) { return Scripting::SetTextFont((Scripting::eTextFont)font); }
		static void SetTextJustify (b8 value) { return Scripting::SetTextJustify(value); }
		static void SetTextLineDisplay (u32 unk1, u32 unk2) { return Scripting::SetTextLineDisplay(unk1, unk2); }
		static void SetTextLineHeightMult (f32 lineHeight) { return Scripting::SetTextLineHeightMult(lineHeight); }
		static void SetTextProportional (b8 value) { return Scripting::SetTextProportional(value); }
		static void SetTextRenderId (u32 renderId) { return Scripting::SetTextRenderId(renderId); }
		static void SetTextRightJustify (b8 value) { return Scripting::SetTextRightJustify(value); }
		static void SetTextToUseTextFileColours (b8 value) { return Scripting::SetTextToUseTextFileColours(value); }
		static void SetTextUseUnderscore (b8 value) { return Scripting::SetTextUseUnderscore(value); }
		static void SetTextWrap (f32 unk1, f32 unk2) { return Scripting::SetTextWrap(unk1, unk2); }

		// Textures
		static GTA::Texture^ GetTexture (GTA::TextureDict^ dictionary, String^ textureName) 
		 {
			marshal_context^ contextureName = gcnew marshal_context();;
			const char* ctextureName = contextureName->marshal_as<const char*>(textureName);
			GTA::Texture^ retval = gcnew GTA::Texture(Scripting::GetTexture(dictionary->Base, ctextureName));
			delete contextureName;
		 return retval;
		 }
		static GTA::Texture^ GetTextureFromStreamedTxd (String^ txdName, String^ textureName) 
		 {
			marshal_context^ contxdName = gcnew marshal_context();;
			const char* ctxdName = contxdName->marshal_as<const char*>(txdName);
			marshal_context^ contextureName = gcnew marshal_context();;
			const char* ctextureName = contextureName->marshal_as<const char*>(textureName);
			GTA::Texture^ retval = gcnew GTA::Texture(Scripting::GetTextureFromStreamedTxd(ctxdName, ctextureName));
			delete contxdName;
		 delete contextureName;
		 return retval;
		 }
		static GTA::TextureDict^ GetTxd (String^ txdName) 
		 {
			marshal_context^ contxdName = gcnew marshal_context();;
			const char* ctxdName = contxdName->marshal_as<const char*>(txdName);
			GTA::TextureDict^ retval = gcnew GTA::TextureDict(Scripting::GetTxd(ctxdName));
			delete contxdName;
		 return retval;
		 }
		static b8 HasStreamedTxdLoaded (String^ txdName) 
		 {
			marshal_context^ contxdName = gcnew marshal_context();;
			const char* ctxdName = contxdName->marshal_as<const char*>(txdName);
			b8 retval = Scripting::HasStreamedTxdLoaded(ctxdName);
			delete contxdName;
		 return retval;
		 }
		static GTA::TextureDict^ LoadTxd (String^ txdName) 
		 {
			marshal_context^ contxdName = gcnew marshal_context();;
			const char* ctxdName = contxdName->marshal_as<const char*>(txdName);
			GTA::TextureDict^ retval = gcnew GTA::TextureDict(Scripting::LoadTxd(ctxdName));
			delete contxdName;
		 return retval;
		 }
		static void MarkStreamedTxdAsNoLongerNeeded (String^ txdName) 
		 {
			marshal_context^ contxdName = gcnew marshal_context();;
			const char* ctxdName = contxdName->marshal_as<const char*>(txdName);
			Scripting::MarkStreamedTxdAsNoLongerNeeded(ctxdName);
			delete contxdName;
		 }
		static void ReleaseTexture (GTA::Texture^ texture) { return Scripting::ReleaseTexture(texture->Base); }
		static void RequestStreamedTxd (String^ txdName, b8 unknown) 
		 {
			marshal_context^ contxdName = gcnew marshal_context();;
			const char* ctxdName = contxdName->marshal_as<const char*>(txdName);
			Scripting::RequestStreamedTxd(ctxdName, unknown);
			delete contxdName;
		 }
		static void RemoveTxd (GTA::TextureDict^ txd) { return Scripting::RemoveTxd(txd->Base); }

		// Stats
		static void DecrementIntStat (GTA::eIntStatistic stat, u32 amount) { return Scripting::DecrementIntStat((Scripting::eIntStatistic)stat, amount); }
		static u32 GetIntStat (GTA::eIntStatistic stat) { return Scripting::GetIntStat((Scripting::eIntStatistic)stat); }
		static void IncrementFloatStatNoMessage (GTA::eFloatStatistic stat, f32 value) { return Scripting::IncrementFloatStatNoMessage((Scripting::eFloatStatistic)stat, value); }
		static void IncrementIntStat (GTA::eIntStatistic stat, u32 value) { return Scripting::IncrementIntStat((Scripting::eIntStatistic)stat, value); }
		static void IncrementIntStatNoMessage (GTA::eIntStatistic stat, u32 value) { return Scripting::IncrementIntStatNoMessage((Scripting::eIntStatistic)stat, value); }
		static void SetIntStat (GTA::eIntStatistic stat, u32 value) { return Scripting::SetIntStat((Scripting::eIntStatistic)stat, value); }

		// Pad (controls)
		static b8 GetPadPitchRoll (u32 padIndex, f32* pPitch, f32* pRoll) { return Scripting::GetPadPitchRoll(padIndex, pPitch, pRoll); }
		static void GetPositionOfAnalogueSticks (u32 padIndex, u32* pLeftX, u32* pLeftY, u32* pRightX, u32* pRightY) { return Scripting::GetPositionOfAnalogueSticks(padIndex, pLeftX, pLeftY, pRightX, pRightY); }
		static b8 IsButtonJustPressed (u32 padIndex, GTA::ePadButton button) { return Scripting::IsButtonJustPressed(padIndex, (Scripting::ePadButton)button); }
		static b8 IsButtonPressed (u32 padIndex, GTA::ePadButton button) { return Scripting::IsButtonPressed(padIndex, (Scripting::ePadButton)button); }

		// Sound
		static GTA::eSound GetSoundId () { return (GTA::eSound) Scripting::GetSoundId(); }
		static b8 HasSoundFinished (GTA::eSound sound) { return Scripting::HasSoundFinished((Scripting::eSound)sound); }
		static void PlayAudioEvent (String^ name) 
		 {
			char* cname = (char*)Marshal::StringToHGlobalAnsi(name).ToPointer();
			Scripting::PlayAudioEvent(cname);
			 Marshal::FreeHGlobal((IntPtr)cname);
		 }
		static void PlaySoundFrontend (GTA::eSound sound, String^ soundName) 
		 {
			char* csoundName = (char*)Marshal::StringToHGlobalAnsi(soundName).ToPointer();
			Scripting::PlaySoundFrontend((Scripting::eSound)sound, csoundName);
			 Marshal::FreeHGlobal((IntPtr)csoundName);
		 }
		static void SetVariableOnSound (GTA::eSound sound, String^ varname, f32 value) 
		 {
			char* cvarname = (char*)Marshal::StringToHGlobalAnsi(varname).ToPointer();
			Scripting::SetVariableOnSound((Scripting::eSound)sound, cvarname, value);
			 Marshal::FreeHGlobal((IntPtr)cvarname);
		 }
		static void StopSound (GTA::eSound sound) { return Scripting::StopSound((Scripting::eSound)sound); }
		static void ReleaseSoundId (GTA::eSound sound) { return Scripting::ReleaseSoundId((Scripting::eSound)sound); }

		// Time
		static void ForceTimeOfDay (u32 hour, u32 minute) { return Scripting::ForceTimeOfDay(hour, minute); }
		static void ForwardToTimeOfDay (u32 hour, u32 minute) { return Scripting::ForwardToTimeOfDay(hour, minute); }
		static void GetCurrentDate (u32* day, u32* month) { return Scripting::GetCurrentDate(day, month); }
		static u32 GetCurrentDayOfWeek () { return Scripting::GetCurrentDayOfWeek(); }
		static u32 GetHoursOfDay () { return Scripting::GetHoursOfDay(); }
		static u32 GetMinutesOfDay () { return Scripting::GetMinutesOfDay(); }
		static u32 GetMinutesToTimeOfDay (u32 hour, u32 minute) { return Scripting::GetMinutesToTimeOfDay(hour, minute); }
		static void GetTimeOfDay (u32* hour, u32* minute) { return Scripting::GetTimeOfDay(hour, minute); }
		static void ReleaseTimeOfDay () { return Scripting::ReleaseTimeOfDay(); }
		static void SetTimeOfDay (u32 hour, u32 minute) { return Scripting::SetTimeOfDay(hour, minute); }
		static void SetTimeOneDayBack () { return Scripting::SetTimeOneDayBack(); }
		static void SetTimeOneDayForward () { return Scripting::SetTimeOneDayForward(); }
		static void SetTimeScale (f32 scale) { return Scripting::SetTimeScale(scale); }

		// Fires
		static b8 IsScriptFireExtinguished (Scripting::FireId fire) { return Scripting::IsScriptFireExtinguished(fire); }
		static void RemoveScriptFire (Scripting::FireId fire) { return Scripting::RemoveScriptFire(fire); }
		static Scripting::FireId StartCarFire (GTA::Vehicle^ vehicle) { return Scripting::StartCarFire(vehicle->Base); }
		static Scripting::FireId StartCharFire (GTA::Ped^ ped) { return Scripting::StartCharFire(ped->Base); }
		static Scripting::FireId StartScriptFire (f32 x, f32 y, f32 z, u8 numGenerationsAllowed, u32 strength) { return Scripting::StartScriptFire(x, y, z, numGenerationsAllowed, strength); }

		// Radio
		static void DisableFrontEndRadio () { return Scripting::DisableFrontEndRadio(); }
		static void EnableFrontEndRadio () { return Scripting::EnableFrontEndRadio(); }
		static void FreezeRadioStation (String^ stationName) 
		 {
			marshal_context^ constationName = gcnew marshal_context();;
			const char* cstationName = constationName->marshal_as<const char*>(stationName);
			Scripting::FreezeRadioStation(cstationName);
			delete constationName;
		 }
		static GTA::eRadioStation GetPlayerRadioStationIndex () { return (GTA::eRadioStation) Scripting::GetPlayerRadioStationIndex(); }
		//ConvertMe//    static constchr *GetPlayerRadioStationName() { return NativeInvoke::Invoke<NATIVE_GET_PLAYER_RADIO_STATION_NAME, constchr *>(); }
		static b8 IsRadioRetuning () { return Scripting::IsRadioRetuning(); }
		static void RetuneRadioToStationIndex (GTA::eRadioStation radioStation) { return Scripting::RetuneRadioToStationIndex((Scripting::eRadioStation)radioStation); }

		// Game/Misc
		static void AbortAllGarageActivity () { return Scripting::AbortAllGarageActivity(); }
		static void ActivateCheat (GTA::eCheat cheat) { return Scripting::ActivateCheat((Scripting::eCheat)cheat); }
		static void ActivateFrontEnd () { return Scripting::ActivateFrontEnd(); }
		static void ActivateSaveMenu () { return Scripting::ActivateSaveMenu(); }
		static void AddExplosion (f32 x, f32 y, f32 z, u32 p3, f32 p4, u32 p5, u32 p6, f32 p7) { return Scripting::AddExplosion(x, y, z, p3, p4, p5, p6, p7); }
		static void AllowEmergencyServices (b8 allow) { return Scripting::AllowEmergencyServices(allow); }
		static void AllowGameToPauseForStreaming (b8 allow) { return Scripting::AllowGameToPauseForStreaming(allow); }
		static void AllowStuntJumpsToTrigger (b8 allow) { return Scripting::AllowStuntJumpsToTrigger(allow); }
		static b8 AreWidescreenBordersActive () { return Scripting::AreWidescreenBordersActive(); }
		static Scripting::ScriptAny AwardAchievement (GTA::eAchievement achievement) { return Scripting::AwardAchievement((Scripting::eAchievement)achievement); }
		static b8 CanPhoneBeSeenOnScreen () { return Scripting::CanPhoneBeSeenOnScreen(); }
		static void CancelOverrideRestart () { return Scripting::CancelOverrideRestart(); }
		static void ClearShakePlayerPadWhenControllerDisabled () { return Scripting::ClearShakePlayerPadWhenControllerDisabled(); }
		static void ClearTimeCycleModifier () { return Scripting::ClearTimeCycleModifier(); }
		static void DeactivateFrontEnd () { return Scripting::DeactivateFrontEnd(); }
		static b8 DidSaveCompleteSuccessfully () { return Scripting::DidSaveCompleteSuccessfully(); }
		static void DisablePauseMenu (b8 disabled) { return Scripting::DisablePauseMenu(disabled); }
		static void DisablePoliceScanner () { return Scripting::DisablePoliceScanner(); }
		static void DisplayAmmo (b8 display) { return Scripting::DisplayAmmo(display); }
		static void DisplayAreaName (b8 display) { return Scripting::DisplayAreaName(display); }
		static void DisplayCash (b8 display) { return Scripting::DisplayCash(display); }
		static void DisplayFrontEndMapBlips (b8 display) { return Scripting::DisplayFrontEndMapBlips(display); }
		static void DisplayHUD (b8 display) { return Scripting::DisplayHUD(display); }
		static void DisplayRadar (b8 display) { return Scripting::DisplayRadar(display); }
		static void DisplaySniperScopeThisFrame () { return Scripting::DisplaySniperScopeThisFrame(); }
		static void DoAutoSave () { return Scripting::DoAutoSave(); }
		static void DoScreenFadeIn (u32 timeMS) { return Scripting::DoScreenFadeIn(timeMS); }
		static void DoScreenFadeInUnhacked (u32 timeMS) { return Scripting::DoScreenFadeInUnhacked(timeMS); }
		static void DoScreenFadeOut (u32 timeMS) { return Scripting::DoScreenFadeOut(timeMS); }
		static void DoScreenFadeOutUnhacked (u32 timeMS) { return Scripting::DoScreenFadeOutUnhacked(timeMS); }
		static void DrawRect (f32 x1, f32 y1, f32 x2, f32 y2, u8 r, u8 g, u8 b, u8 a) { return Scripting::DrawRect(x1, y1, x2, y2, r, g, b, a); }
		static void EnableMaxAmmoCap (b8 enable) { return Scripting::EnableMaxAmmoCap(enable); }
		static void EnablePoliceScanner () { return Scripting::EnablePoliceScanner(); }
		static void EnableSceneStreaming (b8 enable) { return Scripting::EnableSceneStreaming(enable); }
		static void FakeDeathArrest () { return Scripting::FakeDeathArrest(); }
		static void FindStreetNameAtPosition (f32 pX, f32 pY, f32 pZ, u32* strHash0, u32* strHash1) { return Scripting::FindStreetNameAtPosition(pX, pY, pZ, strHash0, strHash1); }
		static void FireSingleBullet (f32 x, f32 y, f32 z, f32 targetX, f32 targetY, f32 targetZ, u32 unknown) { return Scripting::FireSingleBullet(x, y, z, targetX, targetY, targetZ, unknown); }
		static void FlashWeaponIcon (b8 on) { return Scripting::FlashWeaponIcon(on); }
		static void ForceInitialPlayerStation (String^ stationName) 
		 {
			marshal_context^ constationName = gcnew marshal_context();;
			const char* cstationName = constationName->marshal_as<const char*>(stationName);
			Scripting::ForceInitialPlayerStation(cstationName);
			delete constationName;
		 }
		static void ForceLoadingScreen (b8 force) { return Scripting::ForceLoadingScreen(force); }
		static void GetCorrectedColour (u32 r, u32 g, u32 b, u32* pR, u32* pG, u32* pB) { return Scripting::GetCorrectedColour(r, g, b, pR, pG, pB); }
		static b8 GetCreateRandomCops () { return Scripting::GetCreateRandomCops(); }
		static u32 GetCurrentEpisode () { return Scripting::GetCurrentEpisode(); }
		static Scripting::eLanguage GetCurrentLanguage () { return Scripting::GetCurrentLanguage(); }
		static u32 GetEpisodeIndexFromSummons () { return Scripting::GetEpisodeIndexFromSummons(); }
		//ConvertMe//    static constchr * GetEpisodeName(u32 episodeIndex) { return NativeInvoke::Invoke<NATIVE_GET_EPISODE_NAME, constchr *>(episodeIndex); }
		static f32 GetFloatStat (GTA::eFloatStatistic stat) { return Scripting::GetFloatStat((Scripting::eFloatStatistic)stat); }
		static void GetFrameTime (f32* time) { return Scripting::GetFrameTime(time); }
		static void GetGameTimer (u32* pTimer) { return Scripting::GetGameTimer(pTimer); }
		static u32 GetHashKey (String^ value) 
		 {
			marshal_context^ convalue = gcnew marshal_context();;
			const char* cvalue = convalue->marshal_as<const char*>(value);
			u32 retval = Scripting::GetHashKey(cvalue);
			delete convalue;
		 return retval;
		 }
		static void GetHUDColour (GTA::eHUDType type, u32* pR, u32* pG, u32* pB, Scripting::ScriptAny* pUnknown) { return Scripting::GetHUDColour((Scripting::eHUDType)type, pR, pG, pB, pUnknown); }
		static u32 GetIdOfThisThread () { return Scripting::GetIdOfThisThread(); }
		static b8 GetIsDepositAnimRunning () { return Scripting::GetIsDepositAnimRunning(); }
		static b8 GetIsHiDef () { return Scripting::GetIsHiDef(); }
		static b8 GetIsWidescreen () { return Scripting::GetIsWidescreen(); }
		static u32 GetLeftPlayerCashToReachLevel (u32 playerRank) { return Scripting::GetLeftPlayerCashToReachLevel(playerRank); }
		static Scripting::eMapArea GetMapAreaFromCoords (f32 x, f32 y, f32 z) { return Scripting::GetMapAreaFromCoords(x, y, z); }
		static b8 GetMissionFlag () { return Scripting::GetMissionFlag(); }
		static void GetMaxWantedLevel (u32* pMaxWantedLevel) { return Scripting::GetMaxWantedLevel(pMaxWantedLevel); }
		//ConvertMe//    static constchr *GetNameOfInfoZone(f32 x, f32 y, f32 z) { return NativeInvoke::Invoke<NATIVE_GET_NAME_OF_INFO_ZONE, constchr *>(x, y, z); }
		//ConvertMe//    static constchr *GetNameOfZone(f32 x, f32 y, f32 z) { return NativeInvoke::Invoke<NATIVE_GET_NAME_OF_ZONE, constchr *>(x, y, z); }
		static u32 GetNumStreamingRequests () { return Scripting::GetNumStreamingRequests(); }
		static u32 GetNumberOfInstancesOfStreamedScript (String^ scriptName) 
		 {
			marshal_context^ conscriptName = gcnew marshal_context();;
			const char* cscriptName = conscriptName->marshal_as<const char*>(scriptName);
			u32 retval = Scripting::GetNumberOfInstancesOfStreamedScript(cscriptName);
			delete conscriptName;
		 return retval;
		 }
		static u32 GetNumberOfPlayers () { return Scripting::GetNumberOfPlayers(); }
		static u32 GetTimeSinceLastArrest () { return Scripting::GetTimeSinceLastArrest(); }
		static u32 GetTimeSinceLastDeath () { return Scripting::GetTimeSinceLastDeath(); }
		static b8 HasAchievementBeenPassed (GTA::eAchievement achievement) { return Scripting::HasAchievementBeenPassed((Scripting::eAchievement)achievement); }
		static b8 HasDeathArrestExecuted () { return Scripting::HasDeathArrestExecuted(); }
		static b8 HasResprayHappened () { return Scripting::HasResprayHappened(); }
		static b8 HasScriptLoaded (String^ scriptName) 
		 {
			marshal_context^ conscriptName = gcnew marshal_context();;
			const char* cscriptName = conscriptName->marshal_as<const char*>(scriptName);
			b8 retval = Scripting::HasScriptLoaded(cscriptName);
			delete conscriptName;
		 return retval;
		 }
		static b8 HaveAnimsLoaded (String^ animName) 
		 {
			marshal_context^ conanimName = gcnew marshal_context();;
			const char* canimName = conanimName->marshal_as<const char*>(animName);
			b8 retval = Scripting::HaveAnimsLoaded(canimName);
			delete conanimName;
		 return retval;
		 }
		static b8 HaveRequestedPathNodesBeenLoaded (u32 requestId) { return Scripting::HaveRequestedPathNodesBeenLoaded(requestId); }
		static void HideHelpTextThisFrame () { return Scripting::HideHelpTextThisFrame(); }
		static void HideHUDAndRadarThisFrame () { return Scripting::HideHUDAndRadarThisFrame(); }
		static b8 IsAussieVersion () { return Scripting::IsAussieVersion(); }
		static b8 IsAutoAimingOn () { return Scripting::IsAutoAimingOn(); }
		static b8 IsAutoSaveInProgress () { return Scripting::IsAutoSaveInProgress(); }
		static b8 IsInteriorScene () { return Scripting::IsInteriorScene(); }
		static b8 IsFrontEndFading () { return Scripting::IsFrontEndFading(); }
		static b8 IsGameInControlOfMusic () { return Scripting::IsGameInControlOfMusic(); }
		static b8 IsGermanVersion () { return Scripting::IsGermanVersion(); }
		static b8 IsHelpMessageBeingDisplayed () { return Scripting::IsHelpMessageBeingDisplayed(); }
		static b8 IsHintRunning () { return Scripting::IsHintRunning(); }
		static b8 IsHUDPreferenceSwitchedOn () { return Scripting::IsHUDPreferenceSwitchedOn(); }
		static b8 IsHUDReticuleComplex () { return Scripting::IsHUDReticuleComplex(); }
		static b8 IsInSpectatorMode () { return Scripting::IsInSpectatorMode(); }
		static b8 IsLookInverted () { return Scripting::IsLookInverted(); }
		static b8 IsMemoryCardInUse () { return Scripting::IsMemoryCardInUse(); }
		static b8 IsMessageBeingDisplayed () { return Scripting::IsMessageBeingDisplayed(); }
		static b8 IsMinigameInProgress () { return Scripting::IsMinigameInProgress(); }
		static b8 IsMissionCompletePlaying () { return Scripting::IsMissionCompletePlaying(); }
		static b8 IsMobilePhoneCallOngoing () { return Scripting::IsMobilePhoneCallOngoing(); }
		static b8 IsMobilePhoneRadioActive () { return Scripting::IsMobilePhoneRadioActive(); }
		static b8 IsPauseMenuActive () { return Scripting::IsPauseMenuActive(); }
		static b8 IsPayNSprayActive () { return Scripting::IsPayNSprayActive(); }
		static b8 IsPlayerBeingArrested () { return Scripting::IsPlayerBeingArrested(); }
		static b8 IsPlayerOnline () { return Scripting::IsPlayerOnline(); }
		static b8 IsScreenFadedIn () { return Scripting::IsScreenFadedIn(); }
		static b8 IsScreenFadedOut () { return Scripting::IsScreenFadedOut(); }
		static b8 IsScreenFading () { return Scripting::IsScreenFading(); }
		static b8 IsScreenFadingIn () { return Scripting::IsScreenFadingIn(); }
		static b8 IsScreenFadingOut () { return Scripting::IsScreenFadingOut(); }
		static b8 IsSniperInverted () { return Scripting::IsSniperInverted(); }
		static b8 IsSystemUIShowing () { return Scripting::IsSystemUIShowing(); }
		static b8 IsThisAMinigameScript () { return Scripting::IsThisAMinigameScript(); }
		static b8 IsThreadActive (u32 threadId) { return Scripting::IsThreadActive(threadId); }
		static u32 LoadAllPathNodes (bool value) { return Scripting::LoadAllPathNodes(value); }
		static void MarkScriptAsNoLongerNeeded (String^ scriptName) 
		 {
			marshal_context^ conscriptName = gcnew marshal_context();;
			const char* cscriptName = conscriptName->marshal_as<const char*>(scriptName);
			Scripting::MarkScriptAsNoLongerNeeded(cscriptName);
			delete conscriptName;
		 }
		static void PauseGame () { return Scripting::PauseGame(); }
		static void PlayMovie () { return Scripting::PlayMovie(); }
		static void PopulateNow () { return Scripting::PopulateNow(); }
		static void RequestAnims (String^ animName) 
		 {
			marshal_context^ conanimName = gcnew marshal_context();;
			const char* canimName = conanimName->marshal_as<const char*>(animName);
			Scripting::RequestAnims(canimName);
			delete conanimName;
		 }
		static void ReleaseMovie () { return Scripting::ReleaseMovie(); }
		static void ReleaseWeather () { return Scripting::ReleaseWeather(); }
		static void RemoveAnims (String^ animName) 
		 {
			marshal_context^ conanimName = gcnew marshal_context();;
			const char* canimName = conanimName->marshal_as<const char*>(animName);
			Scripting::RemoveAnims(canimName);
			delete conanimName;
		 }
		static void RemoveCoverPoint (GTA::CoverPoint^ coverPoint) { return Scripting::RemoveCoverPoint(coverPoint->Base); }
		static void RemoveIpl (String^ iplName) 
		 {
			marshal_context^ coniplName = gcnew marshal_context();;
			const char* ciplName = coniplName->marshal_as<const char*>(iplName);
			Scripting::RemoveIpl(ciplName);
			delete coniplName;
		 }
		static void RequestIpl (String^ iplName) 
		 {
			marshal_context^ coniplName = gcnew marshal_context();;
			const char* ciplName = coniplName->marshal_as<const char*>(iplName);
			Scripting::RequestIpl(ciplName);
			delete coniplName;
		 }
		static void SetCameraControlsDisabledWithPlayerControls (bool value) { return Scripting::SetCameraControlsDisabledWithPlayerControls(value); }
		static void SetMissionFlag (b8 isMission) { return Scripting::SetMissionFlag(isMission); }
		static void SetFloatStat (GTA::eFloatStatistic stat, f32 value) { return Scripting::SetFloatStat((Scripting::eFloatStatistic)stat, value); }
		static void SetRadarZoom (f32 zoom) { return Scripting::SetRadarZoom(zoom); }
		static void SetTimerA (u32 value) { return Scripting::SetTimerA(value); }
		static void SetTimerB (u32 value) { return Scripting::SetTimerB(value); }
		static void SetWantedMultiplier (f32 multiplier) { return Scripting::SetWantedMultiplier(multiplier); }
		static void TerminateThisScript () { return Scripting::TerminateThisScript(); }
		static u32 TimerA () { return Scripting::TimerA(); }
		static u32 TimerB () { return Scripting::TimerB(); }
		static u32 TimeStep () { return Scripting::TimeStep(); }
		static void UnlockLazlowStation () { return Scripting::UnlockLazlowStation(); }
		static void UnregisterScriptWithAudio () { return Scripting::UnregisterScriptWithAudio(); }
		static void UnPauseGame () { return Scripting::UnPauseGame(); }
		static void Wait (u32 timeInMs) { return Scripting::Wait(timeInMs); }

		// General
		static f32 AbsF (f32 value) { return Scripting::AbsF(value); }
		static f32 AbsI (f32 value) { return Scripting::AbsI(value); }
		static f32 ASin (f32 value) { return Scripting::ASin(value); }
		static f32 ATan (f32 value) { return Scripting::ATan(value); }
		static i32 Ceil (f32 value) { return Scripting::Ceil(value); }
		static f32 Cos (f32 value) { return Scripting::Cos(value); }
		static f32 ToFloat (u32 value) { return Scripting::ToFloat(value); }
		static u32 Floor (f32 value) { return Scripting::Floor(value); }
		static void GenerateRandomFloatInRange (f32 min, f32 max, f32* pValue) { return Scripting::GenerateRandomFloatInRange(min, max, pValue); }
		static void GenerateRandomIntInRange (u32 min, u32 max, u32* pValue) { return Scripting::GenerateRandomIntInRange(min, max, pValue); }
		static void GetAngleBetween2DVectors (f32 x1, f32 y1, f32 x2, f32 y2, f32* pResult) { return Scripting::GetAngleBetween2DVectors(x1, y1, x2, y2, pResult); }
		static void GetDistanceBetweenCoords2D (f32 x1, f32 y1, f32 x2, f32 y2, f32* pDist) { return Scripting::GetDistanceBetweenCoords2D(x1, y1, x2, y2, pDist); }
		static void GetDistanceBetweenCoords3D (f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, f32* pDist) { return Scripting::GetDistanceBetweenCoords3D(x1, y1, z1, x2, y2, z2, pDist); }
		//ConvertMe//    static constchr *GetFirstNCharactersOfLiteralString(constchr *literalString, u32 chars) { return NativeInvoke::Invoke<NATIVE_GET_FIRST_N_CHARACTERS_OF_LITERAL_STRING, constchr *>(literalString, chars); }
		static void GetHeadingFromVector2D (f32 x, f32 y, f32* pHeading) { return Scripting::GetHeadingFromVector2D(x, y, pHeading); }
		static u32 GetLengthOfLiteralString (String^ literalString) 
		 {
			marshal_context^ conliteralString = gcnew marshal_context();;
			const char* cliteralString = conliteralString->marshal_as<const char*>(literalString);
			u32 retval = Scripting::GetLengthOfLiteralString(cliteralString);
			delete conliteralString;
		 return retval;
		 }
		static b8 IsStringNull (String^ str) 
		 {
			marshal_context^ constr = gcnew marshal_context();;
			const char* cstr = constr->marshal_as<const char*>(str);
			b8 retval = Scripting::IsStringNull(cstr);
			delete constr;
		 return retval;
		 }
		static f32 Sin (f32 value) { return Scripting::Sin(value); }
		static f32 Sqrt (f32 value) { return Scripting::Sqrt(value); }
		static f32 Tan (f32 value) { return Scripting::Tan(value); }

	};
};